atendentepro 0.6.5__py3-none-any.whl → 0.6.7__py3-none-any.whl

atendentepro/__init__.py

@@ -158,6 +158,13 @@ from atendentepro.utils import (
     run_with_monkai_tracking,
     # Application Insights
     configure_application_insights,
+    # User Loader
+    create_user_loader,
+    run_with_user_context,
+    extract_phone_from_messages,
+    extract_email_from_messages,
+    extract_user_id_from_messages,
+    load_user_from_csv,
 )
 
 __all__ = [
@@ -253,5 +260,12 @@ __all__ = [
     "run_with_monkai_tracking",
     # Application Insights
     "configure_application_insights",
+    # User Loader
+    "create_user_loader",
+    "run_with_user_context",
+    "extract_phone_from_messages",
+    "extract_email_from_messages",
+    "extract_user_id_from_messages",
+    "load_user_from_csv",
 ]
 

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/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/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,
 )
@@ -157,6 +160,10 @@ class AgentNetwork:
     templates_root: Optional[Path] = None
     current_client: str = "standard"
     
+    # User loading
+    user_loader: Optional[Callable[[List], Optional["UserContext"]]] = None
+    loaded_user_context: Optional["UserContext"] = None
+    
     def get_all_agents(self) -> List:
         """Get list of all configured agents."""
         agents = []
@@ -216,6 +223,9 @@ def create_standard_network(
     agent_filters: Optional[Dict[str, AccessFilter]] = None,
     conditional_prompts: Optional[Dict[str, List[FilteredPromptSection]]] = None,
     filtered_tools: Optional[Dict[str, List[FilteredTool]]] = None,
+    # User loading
+    user_loader: Optional[Callable[[List], Optional[UserContext]]] = None,
+    auto_load_user: bool = False,
 ) -> AgentNetwork:
     """
     Create a standard agent network with proper handoff configuration.
@@ -259,6 +269,10 @@ def create_standard_network(
         agent_filters: Dict mapping agent names to AccessFilter (controls agent access).
         conditional_prompts: Dict mapping agent names to list of FilteredPromptSection.
         filtered_tools: Dict mapping agent names to list of FilteredTool.
+        user_loader: Optional function to load user data from messages. Receives list of
+                    messages and returns UserContext or None. See create_user_loader().
+        auto_load_user: If True, automatically loads user context before agent execution.
+                        Requires user_loader to be configured.
         
     Returns:
         Configured AgentNetwork instance.
@@ -438,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)
@@ -507,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"),
@@ -550,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"),
@@ -561,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"),
@@ -686,6 +776,9 @@ def create_standard_network(
         network.onboarding = onboarding
         onboarding.handoffs = [triage]
     
+    # Store user_loader in network for later use
+    network.user_loader = user_loader
+    
     return network
 
 

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/utils/__init__.py

@@ -19,6 +19,14 @@ from .tracing import (
     # Legacy
     configure_tracing,
 )
+from .user_loader import (
+    create_user_loader,
+    run_with_user_context,
+    extract_phone_from_messages,
+    extract_email_from_messages,
+    extract_user_id_from_messages,
+    load_user_from_csv,
+)
 
 __all__ = [
     # OpenAI Client
@@ -36,5 +44,12 @@ __all__ = [
     "configure_application_insights",
     # Legacy
     "configure_tracing",
+    # User Loader
+    "create_user_loader",
+    "run_with_user_context",
+    "extract_phone_from_messages",
+    "extract_email_from_messages",
+    "extract_user_id_from_messages",
+    "load_user_from_csv",
 ]
 

atendentepro/utils/user_loader.py

@@ -0,0 +1,335 @@
+# -*- coding: utf-8 -*-
+"""
+User Loader utilities for AtendentePro.
+
+Provides functions to load user data from various sources and create UserContext
+objects for enriching agent conversations with user information.
+"""
+
+from __future__ import annotations
+
+import csv
+import re
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional
+
+from atendentepro.models import UserContext
+
+
+def extract_phone_from_messages(messages: List[Dict[str, Any]]) -> Optional[str]:
+    """
+    Extract phone number from user messages.
+    
+    Searches for phone patterns in the first user message.
+    Supports formats: (11) 99999-9999, 11999999999, +55 11 99999-9999, etc.
+    
+    Args:
+        messages: List of message dictionaries with 'role' and 'content' keys.
+        
+    Returns:
+        Phone number string if found, None otherwise.
+        
+    Example:
+        >>> messages = [{"role": "user", "content": "Meu telefone é (11) 99999-8888"}]
+        >>> extract_phone_from_messages(messages)
+        '11999998888'
+    """
+    if not messages:
+        return None
+    
+    # Find first user message
+    user_message = None
+    for msg in messages:
+        if msg.get("role") == "user" and msg.get("content"):
+            user_message = msg["content"]
+            break
+    
+    if not user_message:
+        return None
+    
+    # Phone patterns: (XX) XXXXX-XXXX, XX XXXXXXXX, +55 XX XXXXXXXX, etc.
+    phone_patterns = [
+        r'\(?(\d{2})\)?\s*(\d{4,5})-?(\d{4})',  # (11) 99999-8888 or 11 99999-8888
+        r'\+?55\s*(\d{2})\s*(\d{4,5})-?(\d{4})',  # +55 11 99999-8888
+        r'(\d{10,11})',  # 11999998888
+    ]
+    
+    for pattern in phone_patterns:
+        match = re.search(pattern, user_message)
+        if match:
+            # Extract digits only
+            digits = re.sub(r'\D', '', match.group(0))
+            # Normalize to 10 or 11 digits (with or without area code)
+            if len(digits) >= 10:
+                return digits[-10:] if len(digits) > 10 else digits
+    
+    return None
+
+
+def extract_email_from_messages(messages: List[Dict[str, Any]]) -> Optional[str]:
+    """
+    Extract email address from user messages.
+    
+    Searches for email patterns in user messages.
+    
+    Args:
+        messages: List of message dictionaries with 'role' and 'content' keys.
+        
+    Returns:
+        Email address string if found, None otherwise.
+        
+    Example:
+        >>> messages = [{"role": "user", "content": "Meu email é joao@example.com"}]
+        >>> extract_email_from_messages(messages)
+        'joao@example.com'
+    """
+    if not messages:
+        return None
+    
+    # Find first user message
+    user_message = None
+    for msg in messages:
+        if msg.get("role") == "user" and msg.get("content"):
+            user_message = msg["content"]
+            break
+    
+    if not user_message:
+        return None
+    
+    # Email pattern
+    email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
+    match = re.search(email_pattern, user_message)
+    
+    if match:
+        return match.group(0).lower()
+    
+    return None
+
+
+def extract_user_id_from_messages(messages: List[Dict[str, Any]]) -> Optional[str]:
+    """
+    Extract user ID from user messages.
+    
+    Looks for common patterns like "user_id:", "id:", "CPF:", etc.
+    
+    Args:
+        messages: List of message dictionaries with 'role' and 'content' keys.
+        
+    Returns:
+        User ID string if found, None otherwise.
+        
+    Example:
+        >>> messages = [{"role": "user", "content": "Meu CPF é 123.456.789-00"}]
+        >>> extract_user_id_from_messages(messages)
+        '12345678900'
+    """
+    if not messages:
+        return None
+    
+    # Find first user message
+    user_message = None
+    for msg in messages:
+        if msg.get("role") == "user" and msg.get("content"):
+            user_message = msg["content"]
+            break
+    
+    if not user_message:
+        return None
+    
+    # Patterns for user IDs
+    patterns = [
+        (r'(?:user[_\s]?id|id[_\s]?usuario|cpf|documento)[:\s]+([\d\.\-\/]+)', lambda m: re.sub(r'\D', '', m.group(1))),
+        (r'([\d]{11})', lambda m: m.group(1)),  # CPF-like (11 digits)
+        (r'([\d]{14})', lambda m: m.group(1)),  # CNPJ-like (14 digits)
+    ]
+    
+    for pattern, extractor in patterns:
+        match = re.search(pattern, user_message, re.IGNORECASE)
+        if match:
+            return extractor(match)
+    
+    return None
+
+
+def load_user_from_csv(
+    csv_path: Path,
+    identifier_field: str,
+    identifier_value: str,
+) -> Optional[Dict[str, Any]]:
+    """
+    Load user data from a CSV file.
+    
+    Args:
+        csv_path: Path to the CSV file.
+        identifier_field: Name of the column to search (e.g., "email", "telefone", "cpf").
+        identifier_value: Value to search for in the identifier_field column.
+        
+    Returns:
+        Dictionary with user data if found, None otherwise.
+        
+    Example:
+        >>> from pathlib import Path
+        >>> user_data = load_user_from_csv(
+        ...     Path("users.csv"),
+        ...     "email",
+        ...     "joao@example.com"
+        ... )
+        >>> if user_data:
+        ...     print(user_data["nome"])
+    """
+    if not csv_path.exists():
+        return None
+    
+    try:
+        with open(csv_path, 'r', encoding='utf-8') as f:
+            reader = csv.DictReader(f)
+            
+            # Normalize identifier value (remove formatting)
+            normalized_value = re.sub(r'\D', '', str(identifier_value).lower())
+            
+            for row in reader:
+                # Get value from identifier field
+                field_value = row.get(identifier_field, '')
+                # Normalize for comparison
+                normalized_field = re.sub(r'\D', '', str(field_value).lower())
+                
+                if normalized_field == normalized_value:
+                    # Return all row data as dict
+                    return dict(row)
+    
+    except Exception:
+        return None
+    
+    return None
+
+
+def create_user_loader(
+    loader_func: Callable[[str], Optional[Dict[str, Any]]],
+    identifier_extractor: Optional[Callable[[List[Dict[str, Any]]], Optional[str]]] = None,
+) -> Callable[[List[Dict[str, Any]]], Optional[UserContext]]:
+    """
+    Create a user loader function.
+    
+    Factory function that creates a callable that extracts user identifier from
+    messages and loads user data using the provided loader function.
+    
+    Args:
+        loader_func: Function that receives an identifier (str) and returns
+                     user data dict or None if not found.
+        identifier_extractor: Optional function to extract identifier from messages.
+                             If None, tries common extractors (phone, email, user_id).
+                             
+    Returns:
+        Function that receives messages and returns UserContext or None.
+        
+    Example:
+        >>> def load_from_db(identifier: str) -> Optional[Dict]:
+        ...     # Your database lookup logic
+        ...     return {"user_id": "123", "role": "cliente", "nome": "João"}
+        ...
+        >>> loader = create_user_loader(
+        ...     loader_func=load_from_db,
+        ...     identifier_extractor=extract_email_from_messages
+        ... )
+        >>> 
+        >>> messages = [{"role": "user", "content": "joao@example.com"}]
+        >>> user_context = loader(messages)
+        >>> if user_context:
+        ...     print(user_context.user_id)
+    """
+    def load_user(messages: List[Dict[str, Any]]) -> Optional[UserContext]:
+        """
+        Load user context from messages.
+        
+        Args:
+            messages: List of message dictionaries.
+            
+        Returns:
+            UserContext if user found, None otherwise.
+        """
+        # Extract identifier
+        identifier = None
+        if identifier_extractor:
+            identifier = identifier_extractor(messages)
+        else:
+            # Try common extractors in order
+            identifier = (
+                extract_phone_from_messages(messages) or
+                extract_email_from_messages(messages) or
+                extract_user_id_from_messages(messages)
+            )
+        
+        if not identifier:
+            return None
+        
+        # Load user data
+        user_data = loader_func(identifier)
+        if not user_data:
+            return None
+        
+        # Create UserContext
+        return UserContext(
+            user_id=user_data.get("user_id") or identifier,
+            role=user_data.get("role"),
+            metadata={
+                **user_data,  # Include all user data in metadata
+                "loaded_from": "user_loader",
+            }
+        )
+    
+    return load_user
+
+
+async def run_with_user_context(
+    network: Any,
+    agent: Any,
+    messages: List[Dict[str, Any]],
+) -> Any:
+    """
+    Run agent with automatic user context loading.
+    
+    This function automatically loads user data if a user_loader is configured
+    in the network, enriches the network's loaded_user_context, and then runs
+    the agent normally.
+    
+    Args:
+        network: AgentNetwork instance with optional user_loader configured.
+        agent: Agent instance to run.
+        messages: List of message dictionaries.
+        
+    Returns:
+        RunResult from the agent execution.
+        
+    Example:
+        >>> from agents import Runner
+        >>> from atendentepro import create_standard_network, create_user_loader
+        >>> from pathlib import Path
+        >>> 
+        >>> def load_user(identifier: str):
+        ...     # Your loading logic
+        ...     return {"user_id": identifier, "role": "cliente"}
+        >>> 
+        >>> loader = create_user_loader(load_user)
+        >>> network = create_standard_network(
+        ...     templates_root=Path("templates"),
+        ...     user_loader=loader
+        ... )
+        >>> 
+        >>> messages = [{"role": "user", "content": "Olá!"}]
+        >>> result = await run_with_user_context(network, network.triage, messages)
+        >>> print(result.final_output)
+    """
+    from agents import Runner
+    
+    # Load user if loader is configured
+    if hasattr(network, 'user_loader') and network.user_loader:
+        try:
+            user_context = network.user_loader(messages)
+            if user_context:
+                network.loaded_user_context = user_context
+        except Exception:
+            # Silently fail if loading fails - don't break the conversation
+            pass
+    
+    # Run agent normally
+    return await Runner.run(agent, messages)

{atendentepro-0.6.5.dist-info → atendentepro-0.6.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atendentepro
-Version: 0.6.5
+Version: 0.6.7
 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>
@@ -96,6 +96,7 @@ Plataforma que unifica múltiplos agentes especializados para resolver demandas
 - [Estilo de Comunicação](#-estilo-de-comunicação-agentstyle)
 - [Single Reply Mode](#-single-reply-mode)
 - [Filtros de Acesso](#-filtros-de-acesso-roleuser)
+- [Carregamento de Usuários](#-carregamento-de-usuários-user-loader)
 - [Múltiplos Agentes](#-múltiplos-agentes-multi-interview--knowledge)
 - [Tracing e Monitoramento](#-tracing-e-monitoramento)
 - [Suporte](#-suporte)
@@ -1040,6 +1041,181 @@ tool_access:
 
 ---
 
+## 👤 Carregamento de Usuários (User Loader)
+
+O **User Loader** identifica automaticamente usuários cadastrados nas conversas e carrega suas informações para enriquecer o contexto, permitindo personalização e evitando onboarding desnecessário.
+
+📂 **Exemplos completos**: [docs/examples/user_loader/](docs/examples/user_loader/)
+
+### Quando Usar
+
+| Cenário | Solução |
+|---------|---------|
+| **Usuário existente** | Identifica automaticamente e pula onboarding |
+| **Personalização** | Carrega dados do usuário para respostas personalizadas |
+| **Contexto enriquecido** | Todos os agentes têm acesso a informações do usuário |
+| **Múltiplas fontes** | Suporta CSV, banco de dados, APIs REST, etc. |
+
+### Funcionalidades
+
+1. **Extração automática** de identificadores (telefone, email, CPF, etc.)
+2. **Carregamento de dados** de múltiplas fontes
+3. **Criação automática** de `UserContext`
+4. **Integração transparente** com a rede de agentes
+
+### Exemplo 1: Carregamento de CSV
+
+```python
+from pathlib import Path
+from atendentepro import (
+    create_standard_network,
+    create_user_loader,
+    load_user_from_csv,
+    extract_email_from_messages,
+    run_with_user_context,
+)
+
+# Função para carregar do CSV
+def load_user(identifier: str):
+    return load_user_from_csv(
+        csv_path=Path("users.csv"),
+        identifier_field="email",
+        identifier_value=identifier
+    )
+
+# Criar loader
+loader = create_user_loader(
+    loader_func=load_user,
+    identifier_extractor=extract_email_from_messages
+)
+
+# Criar network com loader
+network = create_standard_network(
+    templates_root=Path("./templates"),
+    user_loader=loader,
+    include_onboarding=True,
+)
+
+# Executar com carregamento automático
+messages = [{"role": "user", "content": "Meu email é joao@example.com"}]
+result = await run_with_user_context(network, network.triage, messages)
+
+# Verificar se usuário foi carregado
+if network.loaded_user_context:
+    print(f"Usuário: {network.loaded_user_context.metadata.get('nome')}")
+```
+
+### Exemplo 2: Carregamento de Banco de Dados
+
+```python
+import sqlite3
+from atendentepro import create_user_loader, extract_email_from_messages
+
+def load_from_db(identifier: str):
+    conn = sqlite3.connect("users.db")
+    cursor = conn.cursor()
+    cursor.execute("SELECT * FROM users WHERE email = ?", (identifier,))
+    row = cursor.fetchone()
+    conn.close()
+    
+    if row:
+        return {
+            "user_id": row[0],
+            "role": row[1],
+            "nome": row[2],
+            "email": row[3],
+        }
+    return None
+
+loader = create_user_loader(load_from_db, extract_email_from_messages)
+
+network = create_standard_network(
+    templates_root=Path("./templates"),
+    user_loader=loader,
+)
+```
+
+### Exemplo 3: Múltiplos Identificadores
+
+```python
+from atendentepro import (
+    create_user_loader,
+    extract_email_from_messages,
+    extract_phone_from_messages,
+)
+
+def extract_identifier(messages):
+    # Tenta email primeiro
+    email = extract_email_from_messages(messages)
+    if email:
+        return email
+    
+    # Se não encontrou, tenta telefone
+    phone = extract_phone_from_messages(messages)
+    if phone:
+        return phone
+    
+    return None
+
+loader = create_user_loader(
+    loader_func=load_user,
+    identifier_extractor=extract_identifier
+)
+```
+
+### Funções Disponíveis
+
+#### Extratores de Identificador
+
+```python
+from atendentepro import (
+    extract_phone_from_messages,    # Extrai telefone
+    extract_email_from_messages,     # Extrai email
+    extract_user_id_from_messages,  # Extrai CPF/user_id
+)
+```
+
+#### Criar Loader
+
+```python
+from atendentepro import create_user_loader
+
+loader = create_user_loader(
+    loader_func=load_user_function,
+    identifier_extractor=extract_email_from_messages  # Opcional
+)
+```
+
+#### Executar com Contexto
+
+```python
+from atendentepro import run_with_user_context
+
+result = await run_with_user_context(
+    network,
+    network.triage,
+    messages
+)
+```
+
+### Integração com Onboarding
+
+Quando um `user_loader` está configurado:
+
+- ✅ **Usuário encontrado**: Vai direto para o triage, sem passar pelo onboarding
+- ✅ **Usuário não encontrado**: É direcionado para o onboarding normalmente
+- ✅ **Contexto disponível**: Todos os agentes têm acesso a `network.loaded_user_context`
+
+### Benefícios
+
+1. ✅ **Experiência personalizada** - Respostas baseadas em dados do usuário
+2. ✅ **Menos fricção** - Usuários conhecidos não precisam fazer onboarding
+3. ✅ **Contexto rico** - Todos os agentes têm acesso a informações do usuário
+4. ✅ **Flexível** - Suporta múltiplas fontes de dados
+5. ✅ **Automático** - Funciona transparentemente durante a conversa
+
+---
+
 ## 🔀 Múltiplos Agentes (Multi Interview + Knowledge)
 
 O AtendentePro suporta criar **múltiplas instâncias** de Interview e Knowledge agents, cada um especializado em um domínio diferente.

{atendentepro-0.6.5.dist-info → atendentepro-0.6.7.dist-info}/RECORD

@@ -1,12 +1,12 @@
 atendentepro/README.md,sha256=TAXl5GRjhSwz_I-Dx_eN5JOIcUxuE_dz31iMZ_-OnRY,45390
-atendentepro/__init__.py,sha256=ZIN7Nrrx04b5mq4YovL3wk6O6oTY659uffZOI9rYNbE,5820
+atendentepro/__init__.py,sha256=VtJoW9tQ-n-hipu0Lp4gPNWJir1QATouA_CoIl_uY3A,6220
 atendentepro/license.py,sha256=rlPtysXNqAzEQkP2VjUAVu_nMndhPgfKv1yN2ruUYVI,17570
-atendentepro/network.py,sha256=RmNrdf-78qWjlzxB7B8Awa-fJ7ZPQi5iQHZuHBPgVpo,28900
+atendentepro/network.py,sha256=292buwWLglU7ISv5UL9sOXMBU2MObZc31TUtPZZQYuY,33719
 atendentepro/agents/__init__.py,sha256=OcPhG1Dp6xe49B5YIti4HVmaZDoDIrFLfRa8GmI4jpQ,1638
 atendentepro/agents/answer.py,sha256=S6wTchNSTMc0h6d89A4jAzoqecFPVqHUrr55-rCM-p4,2494
 atendentepro/agents/confirmation.py,sha256=bQmIiDaxaCDIWJ3Fxz8h3AHW4kHhwbWSmyLX4y3dtls,2900
-atendentepro/agents/escalation.py,sha256=tnFhHaV8VnrMMh_p8Xt9JTMe4bkWcGb6mChECm8aAvI,17779
-atendentepro/agents/feedback.py,sha256=0cU6LVcIp_2ZBB-Cdprnwgw1C5IKYC_ydQ8HJnlheqo,33585
+atendentepro/agents/escalation.py,sha256=pAS1HANW1jMCBZHekVxvuN9NZ_z9IpAYWbfUzH0Leuw,20540
+atendentepro/agents/feedback.py,sha256=cQd35y2-u93GRmu36ErAMyQEinxvNUaDGblGTGrWCfw,37486
 atendentepro/agents/flow.py,sha256=8SsAQ_f-daOM25EVBTMKGSUI9ywG3y4B0bFcCnrUfo0,2645
 atendentepro/agents/interview.py,sha256=3eWHUw63OJuVpHH-QYtdL8SadRgevNLv2N8Esa4Za2c,2722
 atendentepro/agents/knowledge.py,sha256=Xew_qhAdBrm3oVRvHhKh2oi6aURyeIKU5CtgfAHBYEI,11054
@@ -31,13 +31,14 @@ atendentepro/prompts/knowledge.py,sha256=B3BOyAvzQlwAkR51gc-B6XbQLtwIZlwGP1ofhZ4
 atendentepro/prompts/onboarding.py,sha256=78fSIh2ifsGeoav8DV41_jnyU157c0dtggJujcDvW4U,6093
 atendentepro/prompts/triage.py,sha256=bSdEVheGy03r5P6MQuv7NwhN2_wrt0mK80F9f_LskRU,1283
 atendentepro/templates/__init__.py,sha256=zV1CP2K7_WD219NXl-daTC3Iq8P9sQ7XLmxPEVI2NZg,1575
-atendentepro/templates/manager.py,sha256=s2ezeyEboeMxdcb6oOADQRAm0ikB8Ru4fYC87gfctU0,28819
-atendentepro/utils/__init__.py,sha256=WCJ6_btsLaI6xxHXvNHNue-nKrXWTKscNZGTToQiJ8A,833
+atendentepro/templates/manager.py,sha256=gPj8zPgN3iSHNACaonJU_aSFdevBJ1gpnlHvaiewAHg,34351
+atendentepro/utils/__init__.py,sha256=x2yMUueBilWmI2qASSGbFREeyu0a65r3TuDt0euxNAU,1244
 atendentepro/utils/openai_client.py,sha256=R0ns7SU36vTgploq14-QJMTke1pPxcAXlENDeoHU0L4,4552
 atendentepro/utils/tracing.py,sha256=kpTPw1PF4rR1qq1RyBnAaPIQIJRka4RF8MfG_JrRJ7U,8486
-atendentepro-0.6.5.dist-info/licenses/LICENSE,sha256=TF6CdXxePoT9DXtPnCejiU5mUwWzrFzd1iyWJyoMauA,983
-atendentepro-0.6.5.dist-info/METADATA,sha256=kLTh75smJ0t4HHAGVY7Bcj4XoOzKtrLWL_gcu1OvLEA,40666
-atendentepro-0.6.5.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-atendentepro-0.6.5.dist-info/entry_points.txt,sha256=OP0upzqJF3MLS6VX-M-5BfUwx5YLJO2sJ3YBAp4e6yI,89
-atendentepro-0.6.5.dist-info/top_level.txt,sha256=BFasD4SMmgDUmWKlTIZ1PeuukoRBhyiMIz8umKWVCcs,13
-atendentepro-0.6.5.dist-info/RECORD,,
+atendentepro/utils/user_loader.py,sha256=J8wd-XF2PZg_i1ped8FI8nmGjmUafXROWJa1tYxSDMI,10623
+atendentepro-0.6.7.dist-info/licenses/LICENSE,sha256=TF6CdXxePoT9DXtPnCejiU5mUwWzrFzd1iyWJyoMauA,983
+atendentepro-0.6.7.dist-info/METADATA,sha256=pmB1348o76S-IbRxfu3i3j1MESOWG6exCcEfq9-l6xE,45468
+atendentepro-0.6.7.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+atendentepro-0.6.7.dist-info/entry_points.txt,sha256=OP0upzqJF3MLS6VX-M-5BfUwx5YLJO2sJ3YBAp4e6yI,89
+atendentepro-0.6.7.dist-info/top_level.txt,sha256=BFasD4SMmgDUmWKlTIZ1PeuukoRBhyiMIz8umKWVCcs,13
+atendentepro-0.6.7.dist-info/RECORD,,

{atendentepro-0.6.5.dist-info → atendentepro-0.6.7.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any