atendentepro 0.6.4__py3-none-any.whl → 0.6.6__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/network.py

@@ -157,6 +157,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 +220,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 +266,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.
@@ -686,6 +697,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/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.4.dist-info → atendentepro-0.6.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atendentepro
-Version: 0.6.4
+Version: 0.6.6
 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,8 @@ 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)
 
@@ -1039,6 +1041,317 @@ 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.
+
+📂 **Exemplo completo**: [docs/examples/multi_agents/](docs/examples/multi_agents/)
+
+### Caso de Uso
+
+Empresa que atende diferentes tipos de clientes:
+- **Pessoa Física (PF)**: Produtos de consumo
+- **Pessoa Jurídica (PJ)**: Soluções empresariais
+
+### Arquitetura
+
+```
+                    ┌─────────────────┐
+                    │     Triage      │
+                    │  (entry point)  │
+                    └────────┬────────┘
+                             │
+              ┌──────────────┼──────────────┐
+              │              │              │
+              ▼              ▼              ▼
+    ┌─────────────┐  ┌─────────────┐  ┌─────────────┐
+    │  Interview  │  │  Interview  │  │    Flow     │
+    │     PF      │  │     PJ      │  │   (comum)   │
+    └──────┬──────┘  └──────┬──────┘  └─────────────┘
+           │                │
+           ▼                ▼
+    ┌─────────────┐  ┌─────────────┐
+    │  Knowledge  │  │  Knowledge  │
+    │     PF      │  │     PJ      │
+    └─────────────┘  └─────────────┘
+```
+
+### Implementação
+
+```python
+from atendentepro import (
+    create_custom_network,
+    create_triage_agent,
+    create_interview_agent,
+    create_knowledge_agent,
+)
+
+# 1. Criar agentes especializados
+interview_pf = create_interview_agent(
+    interview_questions="CPF, data de nascimento, renda mensal",
+    name="interview_pf",  # Nome único!
+)
+
+interview_pj = create_interview_agent(
+    interview_questions="CNPJ, razão social, faturamento",
+    name="interview_pj",  # Nome único!
+)
+
+knowledge_pf = create_knowledge_agent(
+    knowledge_about="Produtos para consumidor final",
+    name="knowledge_pf",
+    single_reply=True,
+)
+
+knowledge_pj = create_knowledge_agent(
+    knowledge_about="Soluções empresariais B2B",
+    name="knowledge_pj",
+    single_reply=True,
+)
+
+# 2. Criar Triage
+triage = create_triage_agent(
+    keywords_text="PF: CPF, pessoal, minha conta | PJ: CNPJ, empresa, MEI",
+    name="triage_agent",
+)
+
+# 3. Configurar handoffs
+triage.handoffs = [interview_pf, interview_pj, knowledge_pf, knowledge_pj]
+interview_pf.handoffs = [knowledge_pf, triage]
+interview_pj.handoffs = [knowledge_pj, triage]
+knowledge_pf.handoffs = [triage]
+knowledge_pj.handoffs = [triage]
+
+# 4. Criar network customizada
+network = create_custom_network(
+    triage=triage,
+    custom_agents={
+        "interview_pf": interview_pf,
+        "interview_pj": interview_pj,
+        "knowledge_pf": knowledge_pf,
+        "knowledge_pj": knowledge_pj,
+    },
+)
+```
+
+### Cenários de Roteamento
+
+| Mensagem do Usuário | Rota |
+|---------------------|------|
+| "Quero abrir conta para mim" | Triage → Interview PF → Knowledge PF |
+| "Preciso de maquininha para minha loja" | Triage → Interview PJ → Knowledge PJ |
+| "Quanto custa o cartão gold?" | Triage → Knowledge PF (direto) |
+| "Capital de giro para empresa" | Triage → Knowledge PJ (direto) |
+
+### Padrão: 1 Interview → 2 Knowledge
+
+Outro padrão comum é ter um único Interview que pode direcionar para múltiplos Knowledge:
+
+```
+        ┌───────────────┐
+        │   Interview   │
+        │ (coleta dados)│
+        └───────┬───────┘
+                │
+        ┌───────┴───────┐
+        ▼               ▼
+┌───────────────┐ ┌───────────────┐
+│   Knowledge   │ │   Knowledge   │
+│   Produtos    │ │Troubleshooting│
+└───────────────┘ └───────────────┘
+```
+
+```python
+# Um interview que direciona para múltiplos knowledge
+interview.handoffs = [knowledge_produtos, knowledge_troubleshooting, triage]
+```
+
+📂 **Exemplo completo**: [example_one_interview_two_knowledge.py](docs/examples/multi_agents/example_one_interview_two_knowledge.py)
+
+### Dicas
+
+1. **Nomes únicos**: Cada agente precisa de um `name` distinto
+2. **Handoffs claros**: Configure quais agentes cada um pode chamar
+3. **Keywords no Triage**: Inclua palavras-chave para direcionar corretamente
+4. **single_reply**: Use em Knowledge para evitar loops
+
+---
+
 ## 📊 Tracing e Monitoramento
 
 ### MonkAI Trace (Recomendado)

{atendentepro-0.6.4.dist-info → atendentepro-0.6.6.dist-info}/RECORD

@@ -1,7 +1,7 @@
 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=KJG3forldAH0bqMGv4Nga3RxImZUAf0SaV7SB12rovY,29606
 atendentepro/agents/__init__.py,sha256=OcPhG1Dp6xe49B5YIti4HVmaZDoDIrFLfRa8GmI4jpQ,1638
 atendentepro/agents/answer.py,sha256=S6wTchNSTMc0h6d89A4jAzoqecFPVqHUrr55-rCM-p4,2494
 atendentepro/agents/confirmation.py,sha256=bQmIiDaxaCDIWJ3Fxz8h3AHW4kHhwbWSmyLX4y3dtls,2900
@@ -32,12 +32,13 @@ atendentepro/prompts/onboarding.py,sha256=78fSIh2ifsGeoav8DV41_jnyU157c0dtggJujc
 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/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.4.dist-info/licenses/LICENSE,sha256=TF6CdXxePoT9DXtPnCejiU5mUwWzrFzd1iyWJyoMauA,983
-atendentepro-0.6.4.dist-info/METADATA,sha256=hjjY6FTN3Ht4v_05KO-raxRQkZEuWAxV4ACLtWTnCEs,35702
-atendentepro-0.6.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-atendentepro-0.6.4.dist-info/entry_points.txt,sha256=OP0upzqJF3MLS6VX-M-5BfUwx5YLJO2sJ3YBAp4e6yI,89
-atendentepro-0.6.4.dist-info/top_level.txt,sha256=BFasD4SMmgDUmWKlTIZ1PeuukoRBhyiMIz8umKWVCcs,13
-atendentepro-0.6.4.dist-info/RECORD,,
+atendentepro/utils/user_loader.py,sha256=J8wd-XF2PZg_i1ped8FI8nmGjmUafXROWJa1tYxSDMI,10623
+atendentepro-0.6.6.dist-info/licenses/LICENSE,sha256=TF6CdXxePoT9DXtPnCejiU5mUwWzrFzd1iyWJyoMauA,983
+atendentepro-0.6.6.dist-info/METADATA,sha256=eVxhCtmNVb_xPm7QLRh63SvREKqPzNq6_76nCsJjNnY,45468
+atendentepro-0.6.6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+atendentepro-0.6.6.dist-info/entry_points.txt,sha256=OP0upzqJF3MLS6VX-M-5BfUwx5YLJO2sJ3YBAp4e6yI,89
+atendentepro-0.6.6.dist-info/top_level.txt,sha256=BFasD4SMmgDUmWKlTIZ1PeuukoRBhyiMIz8umKWVCcs,13
+atendentepro-0.6.6.dist-info/RECORD,,

{atendentepro-0.6.4.dist-info → atendentepro-0.6.6.dist-info}/WHEEL

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