atendentepro 0.6.6__tar.gz → 0.6.8__tar.gz

{atendentepro-0.6.6 → atendentepro-0.6.8}/CHANGELOG.md

@@ -5,6 +5,48 @@ All notable changes to AtendentePro will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.6.8] - 2025-02-03
+
+### Fixed
+- **Import Error Fix**: Corrigido `ImportError` ao usar `include_feedback=True` em `create_standard_network`
+  - Adicionadas exportações faltantes em `atendentepro/templates/__init__.py`
+  - `load_feedback_config`, `load_escalation_config`, `load_answer_config` agora estão disponíveis
+  - Modelos `FeedbackConfig`, `EscalationConfig`, `AnswerConfig` agora são exportados corretamente
+
+## [0.6.7] - 2025-02-03
+
+### Fixed
+- **Feedback Agent**: Correção crítica - configuração YAML agora é carregada e aplicada
+  - Removida validação hardcoded de tipos de ticket (agora configurável via YAML)
+  - Adicionada persistência de tickets em arquivo JSON (`feedback_tickets.json`)
+  - Tipos de ticket agora são validados contra `feedback_config.yaml`
+  - Configurações de email (brand_color, brand_name, sla_message) agora vêm do YAML
+- **Escalation Agent**: Correção crítica - configuração YAML agora é carregada e aplicada
+  - Business hours agora configurável via `escalation_config.yaml`
+  - Keywords de prioridade (urgent/high) agora configuráveis via YAML
+  - Conversão automática de dias da semana (monday, tuesday, etc.) para números
+- **Answer Agent**: Correção crítica - `answer_config.yaml` agora é carregado e usado
+  - Template de resposta agora vem do arquivo de configuração
+
+### Added
+- **Novos modelos de configuração em TemplateManager**:
+  - `FeedbackConfig`: Modelo Pydantic para `feedback_config.yaml`
+  - `EscalationConfig`: Modelo Pydantic para `escalation_config.yaml`
+  - `AnswerConfig`: Modelo Pydantic para `answer_config.yaml`
+- **Métodos de carregamento**:
+  - `load_feedback_config()`: Carrega configuração do Feedback Agent
+  - `load_escalation_config()`: Carrega configuração do Escalation Agent
+  - `load_answer_config()`: Carrega configuração do Answer Agent
+- **Persistência de tickets**: Sistema de armazenamento em JSON para tickets do Feedback Agent
+  - Configurável via variável de ambiente `FEEDBACK_STORAGE_PATH`
+  - Carregamento automático ao iniciar
+  - Salvamento automático após cada criação/atualização
+
+### Changed
+- **Feedback Agent**: `create_feedback_agent()` agora aceita `ticket_types` da configuração YAML
+- **Escalation Agent**: `create_escalation_agent()` agora aceita `business_hours` e `priority_keywords` da configuração
+- **Network**: `create_standard_network()` agora carrega e aplica configurações YAML automaticamente
+
 ## [0.6.6] - 2025-01-21
 
 ### Added

{atendentepro-0.6.6 → atendentepro-0.6.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atendentepro
-Version: 0.6.6
+Version: 0.6.8
 Summary: Framework de orquestração de agentes IA com tom e estilo customizáveis. Integra documentos (RAG), APIs e bancos de dados em uma plataforma inteligente multi-agente.
 Author-email: BeMonkAI <contato@monkai.com.br>
 Maintainer-email: BeMonkAI <contato@monkai.com.br>

{atendentepro-0.6.6 → atendentepro-0.6.8}/atendentepro/agents/escalation.py

@@ -47,6 +47,13 @@ DEFAULT_BUSINESS_HOURS = {
     "days": [0, 1, 2, 3, 4],  # Seg-Sex
 }
 
+# Configurable business hours (None = use DEFAULT_BUSINESS_HOURS)
+_configured_business_hours: Optional[Dict[str, Any]] = None
+
+# Configurable priority keywords (None = use defaults)
+_priority_keywords_urgent: Optional[List[str]] = None
+_priority_keywords_high: Optional[List[str]] = None
+
 
 # =============================================================================
 # Storage de Escalações (em memória - substituir por DB em produção)
@@ -139,22 +146,46 @@ def _notificar_equipe(escalation: Escalation) -> bool:
 
 def _verificar_disponibilidade() -> Dict[str, Any]:
     """Verifica se atendimento humano está disponível."""
+    global _configured_business_hours
     agora = datetime.now()
     hora = agora.hour
     dia = agora.weekday()
     
-    # Verificar variáveis de ambiente para horário customizado
-    hora_inicio = int(os.getenv("ESCALATION_HOUR_START", DEFAULT_BUSINESS_HOURS["start"]))
-    hora_fim = int(os.getenv("ESCALATION_HOUR_END", DEFAULT_BUSINESS_HOURS["end"]))
+    # Use configured business hours or fall back to defaults
+    if _configured_business_hours:
+        business_hours = _configured_business_hours
+        hora_inicio = business_hours.get("start", DEFAULT_BUSINESS_HOURS["start"])
+        hora_fim = business_hours.get("end", DEFAULT_BUSINESS_HOURS["end"])
+        days = business_hours.get("days", DEFAULT_BUSINESS_HOURS["days"])
+    else:
+        # Verificar variáveis de ambiente para horário customizado
+        hora_inicio = int(os.getenv("ESCALATION_HOUR_START", DEFAULT_BUSINESS_HOURS["start"]))
+        hora_fim = int(os.getenv("ESCALATION_HOUR_END", DEFAULT_BUSINESS_HOURS["end"]))
+        days = DEFAULT_BUSINESS_HOURS["days"]
+    
+    # Ensure days is a list of integers
+    if isinstance(days, list):
+        days_int = [d if isinstance(d, int) else int(d) for d in days]
+    else:
+        days_int = DEFAULT_BUSINESS_HOURS["days"]
+    
+    disponivel = dia in days_int and hora_inicio <= hora < hora_fim
     
-    disponivel = dia in DEFAULT_BUSINESS_HOURS["days"] and hora_inicio <= hora < hora_fim
+    # Format days for display
+    day_names = ["Segunda", "Terça", "Quarta", "Quinta", "Sexta", "Sábado", "Domingo"]
+    if len(days_int) == 1:
+        dias_atendimento = day_names[days_int[0]]
+    elif len(days_int) == 5 and days_int == [0, 1, 2, 3, 4]:
+        dias_atendimento = "Segunda a Sexta"
+    else:
+        dias_atendimento = ", ".join(day_names[d] for d in sorted(days_int))
     
     return {
         "disponivel": disponivel,
         "hora_atual": agora.strftime("%H:%M"),
-        "dia_semana": ["Segunda", "Terça", "Quarta", "Quinta", "Sexta", "Sábado", "Domingo"][dia],
+        "dia_semana": day_names[dia],
         "horario_atendimento": f"{hora_inicio:02d}:00 - {hora_fim:02d}:00",
-        "dias_atendimento": "Segunda a Sexta",
+        "dias_atendimento": dias_atendimento,
     }
 
 
@@ -166,15 +197,16 @@ def _classificar_prioridade(motivo: str, categoria: str) -> str:
     """
     Classifica automaticamente a prioridade baseado no motivo e categoria.
     """
+    global _priority_keywords_urgent, _priority_keywords_high
     motivo_lower = motivo.lower()
     
-    # Palavras que indicam urgência
-    palavras_urgentes = [
+    # Use configured keywords or defaults
+    palavras_urgentes = _priority_keywords_urgent or [
         "urgente", "emergência", "emergencia", "crítico", "critico",
         "não funciona", "parou", "bloqueado", "cancelar", "prejuízo"
     ]
     
-    palavras_alta = [
+    palavras_alta = _priority_keywords_high or [
         "reclamação", "reclamacao", "insatisfeito", "problema grave",
         "já tentei", "terceira vez", "não resolve"
     ]
@@ -449,6 +481,9 @@ ESCALATION_TOOLS = [
 def create_escalation_agent(
     escalation_triggers: str = "",
     escalation_channels: str = "",
+    business_hours: Optional[Dict[str, Any]] = None,
+    priority_keywords_urgent: Optional[List[str]] = None,
+    priority_keywords_high: Optional[List[str]] = None,
     handoffs: Optional[List] = None,
     tools: Optional[List] = None,
     guardrails: Optional[List["GuardrailCallable"]] = None,
@@ -472,6 +507,9 @@ def create_escalation_agent(
     Args:
         escalation_triggers: Custom triggers for escalation (keywords, situations).
         escalation_channels: Available contact channels description.
+        business_hours: Optional dict with "start", "end", and "days" (list of weekday numbers 0-6 or day names).
+        priority_keywords_urgent: Optional list of keywords that indicate urgent priority.
+        priority_keywords_high: Optional list of keywords that indicate high priority.
         handoffs: List of agents to hand off to (usually triage to return).
         tools: Additional tools (custom notifications, integrations).
         guardrails: List of input guardrails.
@@ -492,6 +530,27 @@ def create_escalation_agent(
         >>> triage.handoffs.append(escalation)
         >>> flow.handoffs.append(escalation)
     """
+    global _configured_business_hours, _priority_keywords_urgent, _priority_keywords_high
+    
+    # Configure business hours
+    if business_hours:
+        # Convert day names to weekday numbers if needed
+        days = business_hours.get("days", [])
+        if days and isinstance(days[0], str):
+            day_map = {
+                "monday": 0, "tuesday": 1, "wednesday": 2, "thursday": 3,
+                "friday": 4, "saturday": 5, "sunday": 6,
+            }
+            days_int = [day_map.get(day.lower(), day) for day in days if day.lower() in day_map]
+            business_hours = {**business_hours, "days": days_int}
+        _configured_business_hours = business_hours
+    else:
+        _configured_business_hours = None
+    
+    # Configure priority keywords
+    _priority_keywords_urgent = priority_keywords_urgent
+    _priority_keywords_high = priority_keywords_high
+    
     if custom_instructions:
         instructions = f"{RECOMMENDED_PROMPT_PREFIX} {custom_instructions}"
     else:

{atendentepro-0.6.6 → atendentepro-0.6.8}/atendentepro/agents/feedback.py

@@ -30,6 +30,7 @@ from email.mime.multipart import MIMEMultipart
 from typing import Optional, List, Dict, Any, TYPE_CHECKING, Callable
 from dataclasses import dataclass, field
 from enum import Enum
+from pathlib import Path
 
 from agents import Agent, function_tool
 
@@ -116,14 +117,22 @@ class Ticket:
 
 
 # =============================================================================
-# Storage (in-memory, replace with DB in production)
+# Storage (in-memory + JSON file persistence)
 # =============================================================================
 
+import json
+
 _tickets_storage: Dict[str, Ticket] = {}
 
 # Protocol prefix (can be customized per client)
 _protocol_prefix: str = "TKT"
 
+# Allowed ticket types (None = accept any type)
+_allowed_ticket_types: Optional[List[str]] = None
+
+# Storage path for persistence
+_storage_path: Optional[Path] = None
+
 # Email configuration
 _email_config: Dict[str, Any] = {
     "enabled": True,
@@ -138,6 +147,8 @@ def configure_feedback_storage(
     email_brand_color: str = "#4A90D9",
     email_brand_name: str = "Atendimento",
     email_sla_message: str = "Retornaremos em até 24h úteis.",
+    allowed_ticket_types: Optional[List[str]] = None,
+    storage_path: Optional[Path] = None,
 ) -> None:
     """
     Configure feedback storage settings.
@@ -147,14 +158,102 @@ def configure_feedback_storage(
         email_brand_color: Hex color for email template branding
         email_brand_name: Brand name for email template
         email_sla_message: SLA message shown in confirmation email
+        allowed_ticket_types: List of allowed ticket types (None = accept any)
+        storage_path: Path to JSON file for persistence (None = use default or env var)
     """
-    global _protocol_prefix, _email_config
+    global _protocol_prefix, _email_config, _allowed_ticket_types, _storage_path
     _protocol_prefix = protocol_prefix
     _email_config.update({
         "brand_color": email_brand_color,
         "brand_name": email_brand_name,
         "sla_message": email_sla_message,
     })
+    _allowed_ticket_types = allowed_ticket_types
+    
+    # Set storage path from parameter, env var, or default
+    if storage_path:
+        _storage_path = Path(storage_path)
+    else:
+        env_path = os.getenv("FEEDBACK_STORAGE_PATH")
+        if env_path:
+            _storage_path = Path(env_path)
+        else:
+            # Default: current working directory
+            _storage_path = Path.cwd() / "feedback_tickets.json"
+
+
+def _get_storage_path() -> Path:
+    """Get the storage path, initializing default if needed."""
+    global _storage_path
+    if _storage_path is None:
+        env_path = os.getenv("FEEDBACK_STORAGE_PATH")
+        if env_path:
+            _storage_path = Path(env_path)
+        else:
+            _storage_path = Path.cwd() / "feedback_tickets.json"
+    return _storage_path
+
+
+def _load_tickets_from_file() -> None:
+    """Load tickets from JSON file into memory."""
+    global _tickets_storage
+    storage_path = _get_storage_path()
+    
+    if not storage_path.exists():
+        return
+    
+    try:
+        with open(storage_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        
+        tickets_data = data.get("tickets", {})
+        _tickets_storage = {}
+        
+        for protocolo, ticket_data in tickets_data.items():
+            # Convert dict back to Ticket dataclass
+            ticket_data["data_criacao"] = datetime.fromisoformat(ticket_data["data_criacao"])
+            ticket_data["data_atualizacao"] = datetime.fromisoformat(ticket_data["data_atualizacao"])
+            _tickets_storage[protocolo.upper()] = Ticket(**ticket_data)
+    except Exception as e:
+        print(f"[Feedback] ⚠️ Erro ao carregar tickets do arquivo: {e}")
+
+
+def _save_tickets_to_file() -> None:
+    """Save tickets from memory to JSON file."""
+    global _tickets_storage
+    storage_path = _get_storage_path()
+    
+    try:
+        # Convert tickets to dict for JSON serialization
+        tickets_data = {}
+        for protocolo, ticket in _tickets_storage.items():
+            ticket_dict = {
+                "protocolo": ticket.protocolo,
+                "tipo": ticket.tipo,
+                "descricao": ticket.descricao,
+                "email_usuario": ticket.email_usuario,
+                "nome_usuario": ticket.nome_usuario,
+                "telefone_usuario": ticket.telefone_usuario,
+                "prioridade": ticket.prioridade,
+                "status": ticket.status,
+                "categoria": ticket.categoria,
+                "data_criacao": ticket.data_criacao.isoformat(),
+                "data_atualizacao": ticket.data_atualizacao.isoformat(),
+                "resposta": ticket.resposta,
+                "atendente": ticket.atendente,
+                "historico": ticket.historico,
+            }
+            tickets_data[protocolo.upper()] = ticket_dict
+        
+        data = {"tickets": tickets_data}
+        
+        # Ensure directory exists
+        storage_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        with open(storage_path, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+    except Exception as e:
+        print(f"[Feedback] ⚠️ Erro ao salvar tickets no arquivo: {e}")
 
 
 def _gerar_protocolo() -> str:
@@ -165,17 +264,25 @@ def _gerar_protocolo() -> str:
 
 
 def _salvar_ticket(ticket: Ticket) -> None:
-    """Save ticket to storage."""
+    """Save ticket to storage (memory + file)."""
     _tickets_storage[ticket.protocolo.upper()] = ticket
+    _save_tickets_to_file()
 
 
 def _buscar_ticket(protocolo: str) -> Optional[Ticket]:
     """Find ticket by protocol."""
+    # Load from file if storage is empty
+    if not _tickets_storage:
+        _load_tickets_from_file()
     return _tickets_storage.get(protocolo.upper())
 
 
 def _listar_tickets(email: Optional[str] = None, status: Optional[str] = None) -> List[Ticket]:
     """List tickets, optionally filtered."""
+    # Load from file if storage is empty
+    if not _tickets_storage:
+        _load_tickets_from_file()
+    
     tickets = list(_tickets_storage.values())
     
     if email:
@@ -456,20 +563,17 @@ def criar_ticket(
     Returns:
         Confirmação com número do protocolo e detalhes
     """
-    # Validar tipo
-    tipos_validos = ["duvida", "feedback", "reclamacao", "sugestao", "elogio", "problema", "outro"]
+    # Validar tipo (se allowed_ticket_types estiver configurado)
     tipo_norm = tipo.lower().strip().replace("ã", "a").replace("ç", "c")
     
-    if tipo_norm not in tipos_validos:
+    if _allowed_ticket_types is not None and tipo_norm not in _allowed_ticket_types:
+        tipos_list = "\n".join(f"- `{t}`" for t in _allowed_ticket_types)
         return f"""❌ **Tipo inválido:** {tipo}
 
 📋 **Tipos aceitos:**
-- `duvida` - Pergunta que precisa de pesquisa
-- `feedback` - Opinião sobre produto/serviço  
-- `reclamacao` - Reclamação formal
-- `sugestao` - Sugestão de melhoria
-- `elogio` - Elogio ou agradecimento
-- `problema` - Problema técnico"""
+{tipos_list}
+
+Por favor, escolha um dos tipos acima."""
     
     # Validar descrição
     if not descricao or len(descricao.strip()) < 10:
@@ -940,6 +1044,7 @@ def create_feedback_agent(
         email_brand_color=email_brand_color,
         email_brand_name=email_brand_name,
         email_sla_message=email_sla_message,
+        allowed_ticket_types=ticket_types,
     )
     
     # Build instructions using prompt builder

{atendentepro-0.6.6 → atendentepro-0.6.8}/atendentepro/network.py

@@ -123,6 +123,9 @@ from atendentepro.templates import (
     load_confirmation_config,
     load_onboarding_config,
     load_access_config,
+    load_feedback_config,
+    load_escalation_config,
+    load_answer_config,
     AccessConfig,
     AccessFilterConfig,
 )
@@ -449,6 +452,39 @@ def create_standard_network(
         confirmation_template = ""
         confirmation_format = ""
     
+    # Load feedback config
+    try:
+        feedback_config = load_feedback_config(client)
+        feedback_protocol_prefix = feedback_config.protocol_prefix
+        feedback_email_config = feedback_config.email
+        feedback_ticket_types = feedback_config.get_ticket_type_names()
+    except FileNotFoundError:
+        feedback_protocol_prefix = feedback_protocol_prefix  # Use parameter default
+        feedback_email_config = {}
+        feedback_ticket_types = None
+    
+    # Load escalation config
+    escalation_config_loaded = False
+    try:
+        escalation_config = load_escalation_config(client)
+        escalation_business_hours = escalation_config.business_hours
+        escalation_priority_keywords = escalation_config.priority
+        escalation_triggers = escalation_config.triggers
+        escalation_channels_config = escalation_config.channels
+        escalation_config_loaded = True
+    except FileNotFoundError:
+        escalation_business_hours = None
+        escalation_priority_keywords = {}
+        escalation_triggers = {}
+        escalation_channels_config = None
+    
+    # Load answer config
+    try:
+        answer_config = load_answer_config(client)
+        answer_template = answer_config.get_answer_template()
+    except FileNotFoundError:
+        answer_template = ""
+    
     # Load guardrails
     try:
         set_guardrails_client(client, templates_root=templates_root)
@@ -518,7 +554,7 @@ def create_standard_network(
     answer = None
     if include_answer and is_agent_allowed("answer"):
         answer = create_answer_agent(
-            answer_template="",
+            answer_template=answer_template,
             guardrails=get_guardrails_for_agent("Answer Agent", templates_root),
             style_instructions=get_full_instructions("answer"),
             single_reply=get_single_reply_for_agent("answer"),
@@ -561,8 +597,44 @@ def create_standard_network(
     # Create escalation agent if requested and allowed
     escalation = None
     if include_escalation and is_agent_allowed("escalation"):
+        # Format escalation triggers from config
+        triggers_text = ""
+        if escalation_triggers:
+            trigger_parts = []
+            if escalation_triggers.get("explicit_request"):
+                trigger_parts.append(f"Pedidos explícitos: {', '.join(escalation_triggers['explicit_request'])}")
+            if escalation_triggers.get("frustration"):
+                trigger_parts.append(f"Indicadores de frustração: {', '.join(escalation_triggers['frustration'])}")
+            if escalation_triggers.get("topics_requiring_human"):
+                trigger_parts.append(f"Tópicos que requerem humano: {', '.join(escalation_triggers['topics_requiring_human'])}")
+            triggers_text = "\n".join(trigger_parts) if trigger_parts else ""
+        
+        # Format escalation channels from config or use parameter
+        if escalation_config_loaded and escalation_channels_config:
+            # Format from config dict
+            channel_parts = []
+            if escalation_channels_config.get("phone", {}).get("enabled"):
+                phone = escalation_channels_config["phone"]
+                channel_parts.append(f"Telefone: {phone.get('number', '')} ({phone.get('hours', '')})")
+            if escalation_channels_config.get("email", {}).get("enabled"):
+                email = escalation_channels_config["email"]
+                channel_parts.append(f"Email: {email.get('address', '')} ({email.get('sla', '')})")
+            if escalation_channels_config.get("whatsapp", {}).get("enabled"):
+                whatsapp = escalation_channels_config["whatsapp"]
+                channel_parts.append(f"WhatsApp: {whatsapp.get('number', '')} ({whatsapp.get('hours', '')})")
+            if channel_parts:
+                channels_text = " | ".join(channel_parts)
+            else:
+                channels_text = escalation_channels  # Use parameter default
+        else:
+            channels_text = escalation_channels  # Use parameter default
+        
         escalation = create_escalation_agent(
-            escalation_channels=escalation_channels,
+            escalation_triggers=triggers_text,
+            escalation_channels=channels_text if isinstance(channels_text, str) else escalation_channels,
+            business_hours=escalation_business_hours,
+            priority_keywords_urgent=escalation_priority_keywords.get("urgent"),
+            priority_keywords_high=escalation_priority_keywords.get("high"),
             tools=get_filtered_tools_for_agent("escalation", tools.get("escalation", [])),
             guardrails=get_guardrails_for_agent("Escalation Agent", templates_root),
             style_instructions=get_full_instructions("escalation"),
@@ -572,10 +644,17 @@ def create_standard_network(
     # Create feedback agent if requested and allowed
     feedback = None
     if include_feedback and is_agent_allowed("feedback"):
+        # Use email config from YAML if available, otherwise use parameters
+        email_color = feedback_email_config.get("brand_color", feedback_brand_color)
+        email_name = feedback_email_config.get("brand_name", feedback_brand_name)
+        email_sla = feedback_email_config.get("sla_message", "Retornaremos em até 24h úteis.")
+        
         feedback = create_feedback_agent(
             protocol_prefix=feedback_protocol_prefix,
-            email_brand_color=feedback_brand_color,
-            email_brand_name=feedback_brand_name,
+            email_brand_color=email_color,
+            email_brand_name=email_name,
+            email_sla_message=email_sla,
+            ticket_types=feedback_ticket_types,
             tools=get_filtered_tools_for_agent("feedback", tools.get("feedback", [])),
             guardrails=get_guardrails_for_agent("Feedback Agent", templates_root),
             style_instructions=get_full_instructions("feedback"),

{atendentepro-0.6.6 → atendentepro-0.6.8}/atendentepro/templates/__init__.py

@@ -17,6 +17,9 @@ from .manager import (
     load_style_config,
     load_single_reply_config,
     load_access_config,
+    load_feedback_config,
+    load_escalation_config,
+    load_answer_config,
     FlowConfig,
     InterviewConfig,
     TriageConfig,
@@ -32,6 +35,9 @@ from .manager import (
     DataSourceConfig,
     DataSourceColumn,
     DocumentConfig,
+    FeedbackConfig,
+    EscalationConfig,
+    AnswerConfig,
 )
 
 __all__ = [
@@ -50,6 +56,9 @@ __all__ = [
     "load_style_config",
     "load_single_reply_config",
     "load_access_config",
+    "load_feedback_config",
+    "load_escalation_config",
+    "load_answer_config",
     "FlowConfig",
     "InterviewConfig",
     "TriageConfig",
@@ -65,5 +74,8 @@ __all__ = [
     "DataSourceConfig",
     "DataSourceColumn",
     "DocumentConfig",
+    "FeedbackConfig",
+    "EscalationConfig",
+    "AnswerConfig",
 ]
 

{atendentepro-0.6.6 → atendentepro-0.6.8}/atendentepro/templates/manager.py

@@ -561,6 +561,112 @@ class AccessConfig(BaseModel):
         return self.tool_access.get(tool_name)
 
 
+class FeedbackConfig(BaseModel):
+    """Configuration model for Feedback Agent."""
+    
+    protocol_prefix: str = "TKT"
+    ticket_types: List[Dict[str, Any]] = Field(default_factory=list)
+    priorities: List[Dict[str, Any]] = Field(default_factory=list)
+    email: Dict[str, Any] = Field(default_factory=dict)
+    messages: Dict[str, str] = Field(default_factory=dict)
+    auto_priority: Dict[str, Any] = Field(default_factory=dict)
+    categories: List[str] = Field(default_factory=list)
+    
+    @classmethod
+    @lru_cache(maxsize=4)
+    def load(cls, path: Path) -> "FeedbackConfig":
+        """Load feedback configuration from YAML file."""
+        if not path.exists():
+            raise FileNotFoundError(f"Feedback config not found at {path}")
+        
+        with open(path, "r", encoding="utf-8") as f:
+            data = yaml.safe_load(f) or {}
+        
+        return cls(
+            protocol_prefix=data.get("protocol_prefix", "TKT"),
+            ticket_types=data.get("ticket_types", []),
+            priorities=data.get("priorities", []),
+            email=data.get("email", {}),
+            messages=data.get("messages", {}),
+            auto_priority=data.get("auto_priority", {}),
+            categories=data.get("categories", []),
+        )
+    
+    def get_ticket_type_names(self) -> List[str]:
+        """Get list of allowed ticket type names."""
+        return [t.get("name", "") for t in self.ticket_types if t.get("name")]
+
+
+class EscalationConfig(BaseModel):
+    """Configuration model for Escalation Agent."""
+    
+    triggers: Dict[str, Any] = Field(default_factory=dict)
+    channels: Dict[str, Any] = Field(default_factory=dict)
+    business_hours: Dict[str, Any] = Field(default_factory=dict)
+    priority: Dict[str, Any] = Field(default_factory=dict)
+    messages: Dict[str, str] = Field(default_factory=dict)
+    notifications: Dict[str, Any] = Field(default_factory=dict)
+    
+    @classmethod
+    @lru_cache(maxsize=4)
+    def load(cls, path: Path) -> "EscalationConfig":
+        """Load escalation configuration from YAML file."""
+        if not path.exists():
+            raise FileNotFoundError(f"Escalation config not found at {path}")
+        
+        with open(path, "r", encoding="utf-8") as f:
+            data = yaml.safe_load(f) or {}
+        
+        return cls(
+            triggers=data.get("triggers", {}),
+            channels=data.get("channels", {}),
+            business_hours=data.get("business_hours", {}),
+            priority=data.get("priority", {}),
+            messages=data.get("messages", {}),
+            notifications=data.get("notifications", {}),
+        )
+    
+    def get_business_hours_days(self) -> List[int]:
+        """Convert YAML day names to weekday numbers (0=Monday, 6=Sunday)."""
+        day_map = {
+            "monday": 0,
+            "tuesday": 1,
+            "wednesday": 2,
+            "thursday": 3,
+            "friday": 4,
+            "saturday": 5,
+            "sunday": 6,
+        }
+        days = self.business_hours.get("days", [])
+        return [day_map.get(day.lower(), day) for day in days if isinstance(day, str) and day.lower() in day_map]
+
+
+class AnswerConfig(BaseModel):
+    """Configuration model for Answer Agent."""
+    
+    instructions: str = ""
+    response_format: Dict[str, Any] = Field(default_factory=dict)
+    
+    @classmethod
+    @lru_cache(maxsize=4)
+    def load(cls, path: Path) -> "AnswerConfig":
+        """Load answer configuration from YAML file."""
+        if not path.exists():
+            raise FileNotFoundError(f"Answer config not found at {path}")
+        
+        with open(path, "r", encoding="utf-8") as f:
+            data = yaml.safe_load(f) or {}
+        
+        return cls(
+            instructions=data.get("instructions", ""),
+            response_format=data.get("response_format", {}),
+        )
+    
+    def get_answer_template(self) -> str:
+        """Get answer template from instructions."""
+        return self.instructions
+
+
 class OnboardingConfig(BaseModel):
     """Configuration model for Onboarding Agent."""
     
@@ -694,6 +800,21 @@ class TemplateManager:
         folder = self.get_template_folder(client)
         return AccessConfig.load(folder / "access_config.yaml")
     
+    def load_feedback_config(self, client: Optional[str] = None) -> FeedbackConfig:
+        """Load feedback configuration for the specified client."""
+        folder = self.get_template_folder(client)
+        return FeedbackConfig.load(folder / "feedback_config.yaml")
+    
+    def load_escalation_config(self, client: Optional[str] = None) -> EscalationConfig:
+        """Load escalation configuration for the specified client."""
+        folder = self.get_template_folder(client)
+        return EscalationConfig.load(folder / "escalation_config.yaml")
+    
+    def load_answer_config(self, client: Optional[str] = None) -> AnswerConfig:
+        """Load answer configuration for the specified client."""
+        folder = self.get_template_folder(client)
+        return AnswerConfig.load(folder / "answer_config.yaml")
+    
     def clear_caches(self) -> None:
         """Clear all configuration caches."""
         FlowConfig.load.cache_clear()
@@ -705,6 +826,9 @@ class TemplateManager:
         StyleConfig.load.cache_clear()
         SingleReplyConfig.load.cache_clear()
         AccessConfig.load.cache_clear()
+        FeedbackConfig.load.cache_clear()
+        EscalationConfig.load.cache_clear()
+        AnswerConfig.load.cache_clear()
 
 
 def get_template_manager() -> TemplateManager:
@@ -808,3 +932,18 @@ def load_access_config(client: Optional[str] = None) -> AccessConfig:
     """Load access configuration for the specified client."""
     return get_template_manager().load_access_config(client)
 
+
+def load_feedback_config(client: Optional[str] = None) -> FeedbackConfig:
+    """Load feedback configuration for the specified client."""
+    return get_template_manager().load_feedback_config(client)
+
+
+def load_escalation_config(client: Optional[str] = None) -> EscalationConfig:
+    """Load escalation configuration for the specified client."""
+    return get_template_manager().load_escalation_config(client)
+
+
+def load_answer_config(client: Optional[str] = None) -> AnswerConfig:
+    """Load answer configuration for the specified client."""
+    return get_template_manager().load_answer_config(client)
+

{atendentepro-0.6.6 → atendentepro-0.6.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "atendentepro"
-version = "0.6.6"
+version = "0.6.8"  # Trigger PyPI publish
 description = "Framework de orquestração de agentes IA com tom e estilo customizáveis. Integra documentos (RAG), APIs e bancos de dados em uma plataforma inteligente multi-agente."
 authors = [
     { name = "BeMonkAI", email = "contato@monkai.com.br" }