letschatty 0.4.305__py3-none-any.whl → 0.4.343__py3-none-any.whl

letschatty/models/company/assets/sale.py

@@ -5,7 +5,7 @@ from ...utils.types.identifier import StrObjectId
 
 class Sale(CompanyAssetModel):
     chat_id: StrObjectId
-    product_id: StrObjectId
+    product_id: Optional[StrObjectId] = Field(default=None)
     quantity: int
     total_amount: float
     currency: str
@@ -16,7 +16,7 @@ class Sale(CompanyAssetModel):
     creator_id: StrObjectId
 
 class SaleRequest(BaseModel):
-    product_id: StrObjectId
+    product_id: Optional[StrObjectId] = Field(default=None)
     quantity: int
     creator_id: StrObjectId
     total_amount: float
@@ -36,4 +36,4 @@ class SaleRequest(BaseModel):
             "paid_amount": 100,
             "installments": 1,
             "details": {}
-        }
+        }

letschatty/models/company/assets/users/user.py

@@ -65,6 +65,7 @@ class UserPreview(ChattyAssetPreview):
     roles: List[UserRole]
     user_type : UserType
     email : Optional[str] = Field(default=None)
+    auto_assign_chats: bool = Field(default=False)
 
     @classmethod
     def not_found(cls, id: StrObjectId, company_id: StrObjectId) -> 'UserPreview':
@@ -80,6 +81,7 @@ class UserPreview(ChattyAssetPreview):
             photo_url="https://files-chatty.s3.us-east-1.amazonaws.com/Disen%CC%83o+sin+ti%CC%81tulo.png",
             roles=[],
             user_type=UserType.HUMAN,
+            auto_assign_chats=False
         )
 
     @classmethod
@@ -92,6 +94,7 @@ class UserPreview(ChattyAssetPreview):
         projection["email"] = 1
         projection["user_type"] = 1
         projection["api_key_expires_at"] = 1
+        projection["auto_assign_chats"] = 1
         return projection
 
     @classmethod
@@ -107,7 +110,8 @@ class UserPreview(ChattyAssetPreview):
             roles=asset.roles,
             user_type=asset.user_type,
             email=asset.email,
-            updated_at=asset.updated_at
+            updated_at=asset.updated_at,
+            auto_assign_chats=asset.auto_assign_chats
         )
 
 class User(CompanyAssetModel):

letschatty/models/company/company_messaging_settgins.py

@@ -13,4 +13,5 @@ class MessagingSettings(BaseModel):
     """Messaging settings for the company"""
     good_quality_score_definition: Optional[str] = Field(default=None, description="The definition of a good quality score")
     products_info_level : ProductsInfoLevel = Field(default=ProductsInfoLevel.NAME, description="Whether to include all products info in the prompt or just the name / description")
-    ai_god_mode : Optional[ChattyAIMode] = Field(default=None, description="The mode of the ai god - null if not active")
+    ai_god_mode : Optional[ChattyAIMode] = Field(default=None, description="The mode of the ai god - null if not active")
+    tagger_instructions: Optional[str] = Field(default=None, description="The instructions for the tagger when using the tagger ai agent")

letschatty/models/company/form_field.py

@@ -1,30 +1,88 @@
-from pydantic import BaseModel, Field
-from typing import Optional, Any
+from pydantic import BaseModel, Field, field_validator, ConfigDict
+from typing import Optional, Any, ClassVar, List
+from letschatty.models.base_models.chatty_asset_model import CompanyAssetModel, ChattyAssetPreview
+import re
 
 
-class FormField(BaseModel):
+class FormFieldPreview(ChattyAssetPreview):
+    """Preview model for FormField - used in list views"""
+    field_key: str = Field(description="Unique key identifier for the field")
+    is_system_field: bool = Field(default=False, description="True if this is a system/standard field")
+    question_example: Optional[str] = Field(default=None, description="Example question for AI")
+    description: Optional[str] = Field(default=None, description="Description of the field")
+
+
+class FormField(CompanyAssetModel):
     """
-    Simple configuration for data collection fields.
+    Company asset for data collection fields.
     AI handles all validation - no regex or type constraints.
+
+    System fields (is_system_field=True) are standard fields that map directly
+    to Client model properties (name, email, phone, document_id, external_id).
+
+    When a system field is customized, a document is created in this same collection
+    with is_system_field=True and the same field_key as the base system field.
+    The field_key serves as the unique identifier for system field customizations.
+
+    field_key is FROZEN after creation - it cannot be changed.
     """
-    field_name: str = Field(description="Unique identifier for the field (e.g., 'email', 'budget')")
+    name: str = Field(description="Display name of the field (e.g., 'Email', 'Budget')")
+    field_key: str = Field(description="Unique key identifier for the field (e.g., 'email', 'budget'). Only letters, numbers, and underscores allowed. Frozen after creation.")
     description: str = Field(
+        default="",
         description="Description of what information this field aims to collect"
     )
     question_example: Optional[str] = Field(
         default=None,
         description="Example of how AI should ask for this information"
     )
-    required: bool = Field(
+    is_system_field: bool = Field(
         default=False,
-        description="Whether this field is required"
+        description="True if this is a system/standard field (cannot be deleted)"
     )
 
+    @field_validator('field_key', mode='before')
+    @classmethod
+    def normalize_field_key(cls, v: str) -> str:
+        """
+        Normalize field_key to only contain lowercase letters, numbers, and underscores.
+        - Converts to lowercase
+        - Replaces spaces and hyphens with underscores
+        - Removes any other special characters
+        - Strips leading/trailing whitespace
+        """
+        if not v:
+            raise ValueError("field_key cannot be empty")
+
+        # Convert to lowercase and strip whitespace
+        normalized = v.lower().strip()
+
+        # Replace spaces and hyphens with underscores
+        normalized = normalized.replace(' ', '_').replace('-', '_')
+
+        # Remove any character that's not a letter, number, or underscore
+        normalized = re.sub(r'[^a-z0-9_]', '', normalized)
+
+        # Remove consecutive underscores
+        normalized = re.sub(r'_+', '_', normalized)
+
+        # Remove leading/trailing underscores
+        normalized = normalized.strip('_')
+
+        if not normalized:
+            raise ValueError("field_key must contain at least one letter or number")
+
+        return normalized
+
+    # Preview class for API responses
+    preview_class: ClassVar[type[FormFieldPreview]] = FormFieldPreview
+
     @classmethod
     def example_email(cls) -> dict:
         """Example email field"""
         return {
-            "field_name": "email",
+            "name": "Email",
+            "field_key": "email",
             "description": "Customer's email address for communication",
             "question_example": "Could you share your email so I can send you more information?",
             "required": True
@@ -34,10 +92,115 @@ class FormField(BaseModel):
     def example_budget(cls) -> dict:
         """Example budget field"""
         return {
-            "field_name": "budget",
+            "name": "Budget",
+            "field_key": "budget",
             "description": "Customer's budget allocation for the project",
-            "question_example": "What's your budget range for this project?",
-            "required": False
+            "question_example": "What's your budget range for this project?"
+        }
+
+
+class SystemFormFields:
+    """
+    Standard system fields available for all companies.
+    These map directly to Client model properties.
+
+    field_key is the unique identifier for system fields.
+    """
+
+    # System field keys (used as identifiers)
+    SYSTEM_KEYS = ["name", "email", "phone", "document_id", "external_id"]
+
+    @classmethod
+    def get_all(cls) -> List[dict]:
+        """Get all system form fields as dicts (for API responses)"""
+        return [
+            cls.name_field(),
+            cls.email_field(),
+            cls.phone_field(),
+            cls.document_id_field(),
+            cls.external_id_field(),
+        ]
+
+    @classmethod
+    def get_all_keys(cls) -> List[str]:
+        """Get all system field keys"""
+        return cls.SYSTEM_KEYS
+
+    @classmethod
+    def is_system_field_key(cls, field_key: str) -> bool:
+        """Check if a field_key belongs to a system field"""
+        return field_key in cls.SYSTEM_KEYS
+
+    @classmethod
+    def get_by_key(cls, field_key: str) -> Optional[dict]:
+        """Get a system field by its field_key"""
+        fields_map = {
+            "name": cls.name_field(),
+            "email": cls.email_field(),
+            "phone": cls.phone_field(),
+            "document_id": cls.document_id_field(),
+            "external_id": cls.external_id_field(),
+        }
+        return fields_map.get(field_key)
+
+    @classmethod
+    def name_field(cls) -> dict:
+        """Standard name field"""
+        return {
+            "field_key": "name",
+            "name": "Nombre",
+            "description": "Nombre del cliente",
+            "question_example": "¿Cuál es tu nombre?",
+            "is_system_field": True,
+            "deleted_at": None
+        }
+
+    @classmethod
+    def email_field(cls) -> dict:
+        """Standard email field"""
+        return {
+            "field_key": "email",
+            "name": "Email",
+            "description": "Dirección de correo electrónico del cliente",
+            "question_example": "¿Podrías compartirme tu email para enviarte más información?",
+            "is_system_field": True,
+            "deleted_at": None
+        }
+
+    @classmethod
+    def phone_field(cls) -> dict:
+        """Standard phone field"""
+        return {
+            "field_key": "phone",
+            "name": "Teléfono",
+            "description": "Número de teléfono del cliente",
+            "question_example": "¿Cuál es tu número de teléfono?",
+            "is_system_field": True,
+            "deleted_at": None
+        }
+
+    @classmethod
+    def document_id_field(cls) -> dict:
+        """Standard document ID field (DNI/ID)"""
+        return {
+            "field_key": "document_id",
+            "name": "DNI / Documento",
+            "description": "Número de documento de identidad del cliente",
+            "question_example": "¿Cuál es tu número de DNI o documento?",
+            "is_system_field": True,
+            "deleted_at": None
+        }
+
+    @classmethod
+    def external_id_field(cls) -> dict:
+        """Standard external/CRM ID field"""
+        return {
+            "field_key": "external_id",
+            "name": "ID Externo / CRM",
+            "description": "Identificador externo del cliente en CRM u otro sistema",
+            "question_example": "¿Tienes un número de cliente o código de referencia?",
+            "is_system_field": True,
+            "deleted_at": None
         }
 
 
@@ -49,7 +212,11 @@ class CollectedData(BaseModel):
     name: Optional[str] = Field(default=None, description="Customer's name")
     email: Optional[str] = Field(default=None, description="Customer's email address")
     phone: Optional[str] = Field(default=None, description="Customer's phone number")
-    document_id: Optional[str] = Field(default=None, description="Customer's DNI/ID number")
+    document_id: Optional[str] = Field(
+        default=None,
+        alias="dni",
+        description="Customer's DNI/ID number"
+    )
 
     # Generic key-value store for any other collected fields
     additional_fields: dict[str, Any] = Field(
@@ -57,6 +224,9 @@ class CollectedData(BaseModel):
         description="Additional collected fields as key-value pairs"
     )
 
+    model_config = ConfigDict(
+        populate_by_name=True
+    )
 
     @classmethod
     def example(cls) -> dict:

letschatty/models/messages/chatty_messages/schema/chatty_content/content_document.py

@@ -1,5 +1,6 @@
 from pydantic import BaseModel, Field, model_validator, ValidationInfo
 from typing import Optional
+from urllib.parse import urlparse, unquote
 from .content_media import ChattyContentMedia
 
 class ChattyContentDocument(ChattyContentMedia):
@@ -8,5 +9,6 @@ class ChattyContentDocument(ChattyContentMedia):
     @model_validator(mode='before')
     def validate_filename(cls, data: dict, info: ValidationInfo):
         if not data.get("filename") and data.get("url"):
-            data["filename"] = data["url"].split("/")[-1]
-        return data
+            parsed = urlparse(data["url"])
+            data["filename"] = unquote(parsed.path.split("/")[-1])
+        return data

letschatty/models/messages/chatty_messages/schema/chatty_content/content_media.py

@@ -1,5 +1,6 @@
 from pydantic import BaseModel, Field, field_validator, HttpUrl
 from typing import Optional
+from urllib.parse import quote
 class ChattyContentMedia(BaseModel):
     id: Optional[str] = Field(description="Unique identifier for the image. Also known as media_id", default="")
     url: str = Field(description="URL of the media from S3")
@@ -11,9 +12,9 @@ class ChattyContentMedia(BaseModel):
     def validate_url(cls, v):
         if not v:
             raise ValueError("URL is required")
-        HttpUrl(v)
-        return v
+        encoded = quote(str(v), safe=":/?&=%#")
+        HttpUrl(encoded)
+        return encoded
     
     def get_body_or_caption(self) -> str:
         return self.caption
-

letschatty/models/utils/custom_exceptions/custom_exceptions.py

@@ -59,6 +59,30 @@ class WhatsAppPayloadValidationError(Exception):
     def __init__(self, message="WhatsApp payload validation error", status_code=400, **context_data):
         super().__init__(message, status_code=status_code, **context_data)
 
+
+class ChatWithActiveContinuousConversation(CustomException):
+    """
+    Raised when an AI agent is triggered on a chat that has an active Continuous Conversation.
+    """
+    def __init__(self, message="Chat has an active continuous conversation", status_code=400, **context_data):
+        super().__init__(message, status_code=status_code, **context_data)
+
+
+class ChattyAIModeOff(CustomException):
+    """
+    Raised when an AI agent is in OFF mode and cannot be triggered.
+    """
+    def __init__(self, message="Chatty AI agent is OFF", status_code=400, **context_data):
+        super().__init__(message, status_code=status_code, **context_data)
+
+
+class MissingAIAgentInChat(CustomException):
+    """
+    Raised when a chat has no AI agent assigned but one is required for the operation.
+    """
+    def __init__(self, message="AI agent not assigned to chat", status_code=404, **context_data):
+        super().__init__(message, status_code=status_code, **context_data)
+
 class UnsuportedChannel(CustomException):
     def __init__(self, message="Channel not supported", status_code=400, **context_data):
         super().__init__(message, status_code=status_code, **context_data)

letschatty/services/ai_agents/smart_follow_up_service_v2.py

@@ -1,5 +1,6 @@
 from typing import List
 from letschatty.models.chat.chat import Chat, FlowStateAssignedToChat
+from letschatty.models.chat.flow_link_state import StateTrigger
 from letschatty.models.company.assets.ai_agents_v2.follow_up_strategy import FollowUpStrategy
 from letschatty.models.company.assets.ai_agents_v2.ai_agents_decision_output import SmartFollowUpDecision, SmartFollowUpDecisionAction
 from letschatty.services.chat.chat_service import ChatService
@@ -85,5 +86,14 @@ class SmartFollowUpService:
             SmartFollowUpService.validate_next_call_time_or_default(decision, smart_follow_up_state.consecutive_count + 1, follow_up_strategy)
             smart_follow_up_state.next_call = decision.next_call_time_value
             ChatService.update_workflow_link(chat=chat, workflow_id=smart_follow_up_state.flow_id, workflow_link=smart_follow_up_state, execution_context=execution_context)
+        elif decision.action == SmartFollowUpDecisionAction.POSTPONE_DELTA_TIME:
+            logger.debug(f"Postponing smart follow up for chat {chat.id} by delta time {decision.next_call_time_value}")
+            SmartFollowUpService.validate_next_call_time_or_default(decision, smart_follow_up_state.consecutive_count + 1, follow_up_strategy)
+            smart_follow_up_state.next_call = decision.next_call_time_value
+            ChatService.update_workflow_link(chat=chat, workflow_id=smart_follow_up_state.flow_id, workflow_link=smart_follow_up_state, execution_context=execution_context)
+        elif decision.action == SmartFollowUpDecisionAction.POSTPONE_TILL_UPDATE:
+            logger.debug(f"Postponing smart follow up for chat {chat.id} till update")
+            smart_follow_up_state.trigger = StateTrigger.CHAT_UPDATE
+            ChatService.update_workflow_link(chat=chat, workflow_id=smart_follow_up_state.flow_id, workflow_link=smart_follow_up_state, execution_context=execution_context)
         else:
             raise ValueError(f"Invalid action: {decision.action}")

letschatty/services/chat/chat_service.py

@@ -28,9 +28,10 @@ from ...models.chat.scheduled_messages import ScheduledMessageStatus
 from ...models.utils.types.identifier import StrObjectId
 from ...models.utils.custom_exceptions.custom_exceptions import AssetAlreadyAssigned, MessageNotFoundError, NotFoundError, MessageAlreadyInChat, MetaErrorNotification, ChatAlreadyAssigned, AlreadyCompleted, ErrorToMantainSafety
 from ..factories.messages.central_notification_factory import CentralNotificationFactory
+from ..factories.messages.chatty_message_factory import from_message_draft
 from ...models.messages.chatty_messages.base.message_draft import ChattyContentAudio, MessageDraft
 from ...models.messages.chatty_messages.schema.chatty_content.content_central import CentralNotificationStatus
-from ...models.messages.chatty_messages.schema import ChattyContext
+from ...models.messages.chatty_messages.schema import ChattyContext, ChattyContentText
 from ...models.utils.types.message_types import MessageType
 from .conversation_topics_service import ConversationTopicsService
 import logging
@@ -211,6 +212,43 @@ class ChatService:
         ChatService.add_central_notification_from_text(chat=chat, body=f"Agente de IA {chatty_ai_agent.name} actualizado en el chat {chat.id} por {execution_context.executor.name}", subtype=MessageSubtype.CHATTY_AI_AGENT_UPDATED)
         return chat.chatty_ai_agent
 
+    @staticmethod
+    def escalate_chatty_ai_agent(
+        chat: Chat,
+        execution_context: ExecutionContext,
+        message: Optional[str] = None,
+        reason: Optional[str] = None
+    ) -> None:
+        """
+        Mark the chat's AI agent as requiring human intervention and add a central notification.
+        """
+        if chat.chatty_ai_agent and not chat.chatty_ai_agent.requires_human_intervention:
+            chat.chatty_ai_agent.requires_human_intervention = True
+            execution_context.set_event_time(datetime.now(tz=ZoneInfo("UTC")))
+        body = "El chat fue escalado a un agente humano"
+        if reason:
+            body = f"{body}. Motivo: {reason}"
+        ChatService.add_central_notification_from_text(
+            chat=chat,
+            body=body,
+            subtype=MessageSubtype.CHATTY_AI_AGENT_NOTIFICATION,
+            content_status=CentralNotificationStatus.WARNING,
+            context=ChattyContext(chain_of_thought_id=execution_context.chain_of_thought_id)
+        )
+        if message:
+            outgoing_context = ChattyContext(chain_of_thought_id=execution_context.chain_of_thought_id)
+            outgoing_message = from_message_draft(
+                MessageDraft(
+                    type=MessageType.TEXT,
+                    content=ChattyContentText(body=message),
+                    context=outgoing_context,
+                    subtype=MessageSubtype.NONE,
+                    is_incoming_message=False
+                ),
+                sent_by=execution_context.executor.id
+            )
+            ChatService.add_message(chat=chat, message=outgoing_message)
+
     @staticmethod
     def add_workflow_link(chat : Chat, link : LinkItem, flow:FlowPreview, execution_context: ExecutionContext, description: str, last_incoming_message_id: Optional[str] = None, next_call: Optional[datetime] = None) -> FlowStateAssignedToChat:
         """
@@ -266,36 +304,46 @@ class ChatService:
         return next((state for state in chat.flow_states if state.is_smart_follow_up), None)
 
     @staticmethod
-    def create_sale(chat : Chat, execution_context: ExecutionContext, sale : Sale, product : Product) -> SaleAssignedToChat:
+    def create_sale(
+        chat: Chat,
+        execution_context: ExecutionContext,
+        sale: Sale,
+        product: Optional[Product],
+        product_ids: Optional[List[StrObjectId]] = None,
+        product_label: Optional[str] = None
+    ) -> SaleAssignedToChat:
         """
         Add a sale to the chat.
         """
         if next((sale for sale in chat.client.sales if sale.asset_id == sale.id), None) is not None:
             raise AssetAlreadyAssigned(f"Sale with id {sale.id} already assigned to chat {chat.id}")
+        label = product_label or (product.name if product else "multiples productos")
+        assigned_product_ids = product_ids or ([product.id] if product else [])
         assigned_asset = SaleAssignedToChat(
             asset_type=ChatAssetType.SALE,
             asset_id=sale.id,
             assigned_at=sale.created_at,
             assigned_by=execution_context.executor.id,
-            product_id=product.id
+            product_id=product.id if product else None,
+            product_ids=assigned_product_ids
         )
         execution_context.set_event_time(assigned_asset.assigned_at)
         bisect.insort(chat.client.sales, assigned_asset)
-        ChatService.create_highlight(chat=chat, execution_context=execution_context, highlight_data=HighlightRequestData(title=f"🛍️ Venta de {product.name}", description=f"Venta de {product.name} creada por {execution_context.executor.name}", starred=False, subtype=MessageSubtype.SALE_ADDED))
-        ChatService.add_central_notification_from_text(chat=chat, body=f"Venta de {product.name} agregada al chat {chat.id} por {execution_context.executor.name}", subtype=MessageSubtype.SALE_ADDED)
+        ChatService.create_highlight(chat=chat, execution_context=execution_context, highlight_data=HighlightRequestData(title=f"🛍️ Venta de {label}", description=f"Venta de {label} creada por {execution_context.executor.name}", starred=False, subtype=MessageSubtype.SALE_ADDED))
+        ChatService.add_central_notification_from_text(chat=chat, body=f"Venta de {label} agregada al chat {chat.id} por {execution_context.executor.name}", subtype=MessageSubtype.SALE_ADDED)
         return assigned_asset
 
     @staticmethod
-    def update_sale(chat : Chat, execution_context: ExecutionContext, sale : Sale, product : Product) -> Sale:
+    def update_sale(chat: Chat, execution_context: ExecutionContext, sale: Sale, product_label: str) -> Sale:
         """
         Update a sale for the chat.
         """
-        ChatService.create_highlight(chat=chat, execution_context=execution_context, highlight_data=HighlightRequestData(title=f"🛍️ Venta actualizada de {product.name}", description=f"Venta de {product.name} actualizada por {execution_context.executor.name}", starred=False, subtype=MessageSubtype.SALE_UPDATED))
-        ChatService.add_central_notification_from_text(chat=chat, body=f"Venta de {product.name} actualizada en el chat {chat.id} por {execution_context.executor.name}", subtype=MessageSubtype.SALE_UPDATED)
+        ChatService.create_highlight(chat=chat, execution_context=execution_context, highlight_data=HighlightRequestData(title=f"🛍️ Venta actualizada de {product_label}", description=f"Venta de {product_label} actualizada por {execution_context.executor.name}", starred=False, subtype=MessageSubtype.SALE_UPDATED))
+        ChatService.add_central_notification_from_text(chat=chat, body=f"Venta de {product_label} actualizada en el chat {chat.id} por {execution_context.executor.name}", subtype=MessageSubtype.SALE_UPDATED)
         return sale
 
     @staticmethod
-    def delete_sale(chat : Chat, execution_context: ExecutionContext, sale_id : StrObjectId, product : Product) -> SaleAssignedToChat:
+    def delete_sale(chat: Chat, execution_context: ExecutionContext, sale_id: StrObjectId, product_label: str) -> SaleAssignedToChat:
         """
         Logically remove a sale from the chat.
         """
@@ -303,8 +351,8 @@ class ChatService:
             assigned_asset_to_remove = next(sale for sale in chat.client.sales if sale.asset_id == sale_id)
             chat.client.sales.remove(assigned_asset_to_remove)
             execution_context.set_event_time(datetime.now(tz=ZoneInfo("UTC")))
-            ChatService.create_highlight(chat=chat, execution_context=execution_context, highlight_data=HighlightRequestData(title=f"🛍️ Venta eliminada de {product.name}", description=f"Venta de {product.name} eliminada por {execution_context.executor.name}", starred=False, subtype=MessageSubtype.SALE_DELETED))
-            ChatService.add_central_notification_from_text(chat=chat, body=f"Venta de {product.name} eliminada del chat {chat.id} por {execution_context.executor.name}", subtype=MessageSubtype.SALE_DELETED)
+            ChatService.create_highlight(chat=chat, execution_context=execution_context, highlight_data=HighlightRequestData(title=f"🛍️ Venta eliminada de {product_label}", description=f"Venta de {product_label} eliminada por {execution_context.executor.name}", starred=False, subtype=MessageSubtype.SALE_DELETED))
+            ChatService.add_central_notification_from_text(chat=chat, body=f"Venta de {product_label} eliminada del chat {chat.id} por {execution_context.executor.name}", subtype=MessageSubtype.SALE_DELETED)
             return assigned_asset_to_remove
         except StopIteration:
             raise NotFoundError(message=f"Sale with id {sale_id} not found in chat {chat.id}")
@@ -663,7 +711,10 @@ class ChatService:
         if client_data.external_id is not None:
             chat.client.external_id = client_data.external_id
         if client_data.lead_form_data is not None:
-            chat.client.lead_form_data = client_data.lead_form_data
+            # Merge with existing lead_form_data instead of replacing
+            if chat.client.lead_form_data is None:
+                chat.client.lead_form_data = {}
+            chat.client.lead_form_data.update(client_data.lead_form_data)
         execution_context.set_event_time(datetime.now(tz=ZoneInfo("UTC")))
         ChatService.add_central_notification_from_text(chat=chat, body=f"La info del cliente fue actualizada por {execution_context.executor.name}", subtype=MessageSubtype.CLIENT_INFO_UPDATED)
         return chat
@@ -846,6 +897,13 @@ class ChatService:
             chat.client.email = collected_data.email
             updated_fields.append("email")
 
+        if collected_data.phone:
+            if chat.client.lead_form_data is None:
+                chat.client.lead_form_data = {}
+            if chat.client.lead_form_data.get("phone") != collected_data.phone:
+                chat.client.lead_form_data["phone"] = collected_data.phone
+                updated_fields.append("phone")
+
         if collected_data.document_id and chat.client.document_id != collected_data.document_id:
             chat.client.document_id = collected_data.document_id
             updated_fields.append("document_id")
@@ -863,11 +921,18 @@ class ChatService:
             execution_context.set_event_time(datetime.now(tz=ZoneInfo("UTC")))
             logger.info(f"Updated collected data for chat {chat.id}: {', '.join(updated_fields)}")
 
+            field_label_map = {
+                "name": "nombre",
+                "email": "email",
+                "phone": "telefono",
+                "document_id": "dni",
+            }
+            display_fields = [field_label_map.get(field, field) for field in updated_fields]
             ChatService.add_central_notification_from_text(
                 chat=chat,
-                body=f"Collected customer data: {', '.join(updated_fields)}",
+                body=f"Datos del cliente recopilados: {', '.join(display_fields)}",
                 subtype=MessageSubtype.CLIENT_INFO_UPDATED,
                 context=ChattyContext(chain_of_thought_id=execution_context.chain_of_thought_id)
             )
 
-        return chat.client.lead_form_data
+        return chat.client.lead_form_data

letschatty/services/factories/analytics/events_factory.py

@@ -321,7 +321,7 @@ class EventFactory:
         return events
 
     @staticmethod
-    def funnel_stage_events(chat_with_assets: ChatWithAssets, company_info: EmpresaModel, trace_id: str,executor_type: ExecutorType, executor_id: StrObjectId, chat_funnel: ClientFunnel, funnel_transition: StageTransition, event_type: EventType, time: datetime, company_snapshot: Optional[CompanyChatsSnapshot] = None, agent_snapshot: Optional[AgentChatsSnapshot] = None) -> List[Event]:
+    def funnel_stage_events(chat_with_assets: ChatWithAssets, company_info: EmpresaModel, trace_id: str,executor_type: ExecutorType, executor_id: StrObjectId, chat_funnel: ChatFunnel, funnel_transition: StageTransition, event_type: EventType, time: datetime, company_snapshot: Optional[CompanyChatsSnapshot] = None, agent_snapshot: Optional[AgentChatsSnapshot] = None) -> List[Event]:
         events = []
         base_data = EventFactory._create_base_customer_event_data(
                                                                     chat_with_assets=chat_with_assets,
@@ -334,8 +334,10 @@ class EventFactory:
         funnel_data = FunnelEventData(
             **base_data.model_dump(),
             funnel_id=chat_funnel.funnel_id,
-            funnel_stage_transition=funnel_transition,
-            time_in_funnel_seconds=chat_funnel.time_in_funnel_seconds
+            chat_funnel_id=chat_funnel.id,
+            stage_transition=funnel_transition,
+            time_in_funnel_seconds=chat_funnel.time_in_funnel_seconds,
+            time_in_last_stage_seconds=chat_funnel.time_in_current_stage_seconds
         )
         event = ChatFunnelEvent(
             specversion=EventFactory.package_version(),

letschatty/services/users/user_factory.py

@@ -129,11 +129,17 @@ class UserFactory:
 
     @staticmethod
     def create_updated_user(user: User, user_update_info: UserUpdateInfo) -> User:
-        user_copy = User(**user.model_dump_json())
-        user_copy.name = user_update_info.name if user_update_info.name else user.name
-        user_copy.email = user_update_info.email if user_update_info.email else user.email
-        user_copy.phone_number = user_update_info.phone_number if user_update_info.phone_number else user.phone_number
-        user_copy.photo_url = user_update_info.photo_url if user_update_info.photo_url else user.photo_url
-        user_copy.notifications = user_update_info.notifications if user_update_info.notifications else user.notifications
-        user_copy.auto_assign_chats = user_update_info.auto_assign_chats if user_update_info.auto_assign_chats is not None else user.auto_assign_chats
-        return user_copy
+        update_data = {}
+        if user_update_info.name:
+            update_data['name'] = user_update_info.name
+        if user_update_info.email:
+            update_data['email'] = user_update_info.email
+        if user_update_info.phone_number:
+            update_data['phone_number'] = user_update_info.phone_number
+        if user_update_info.photo_url:
+            update_data['photo_url'] = user_update_info.photo_url
+        if user_update_info.notifications:
+            update_data['notifications'] = user_update_info.notifications
+        if user_update_info.auto_assign_chats is not None:
+            update_data['auto_assign_chats'] = user_update_info.auto_assign_chats
+        return user.update_from_dict(**update_data)

letschatty/services/validators/analytics_validator.py

@@ -10,6 +10,10 @@ if TYPE_CHECKING:
 
 class SourcesAndTopicsValidator:
     """This class provides methods to validate sources and topics."""
+    @staticmethod
+    def normalize_source_name(name: str) -> str:
+        return name.strip().lower()
+
     @staticmethod
     def source_validation_check(sources : Dict[str,Source], topics : Dict[str,Topic], source : Source, existing_source_id : str | None = None) -> None:
         """Checks validation of a source against other sources and topics."""
@@ -28,9 +32,16 @@ class SourcesAndTopicsValidator:
         """This method checks that no duplicated source is created.
         For Pure Ads, it checks that the ad_id is unique and doesn't exist already.
         For Other Sources, it checks that exact trigger doesn't exist already. """
+        normalized_name = SourcesAndTopicsValidator.normalize_source_name(source.name)
+        existing_source_name = None
+        if existing_source_id and existing_source_id in sources:
+            existing_source_name = SourcesAndTopicsValidator.normalize_source_name(sources[existing_source_id].name)
+        should_check_name = existing_source_name is None or normalized_name != existing_source_name
         for source_id, source_to_check in sources.items():
             if source_id == existing_source_id:
                 continue
+            if should_check_name and SourcesAndTopicsValidator.normalize_source_name(source_to_check.name) == normalized_name:
+                raise ConflictedSource(f":warning: *Conflict while adding source: Name already exists* \n New source '{source.name}' \n- Id {source.id} \n Existing source '{source_to_check.name}' \n- Id {source_to_check.id}", conflicting_source_id=source_to_check.id)
             if source == source_to_check: #type: ignore
                 if isinstance(source, OtherSource):
                     raise ConflictedSource(f":warning: *Conflict while adding source: Trigger already exists* \n New source '{source.name}' \n- Id {source.id} \n- Trigger {source.trigger[:30]} \n Existing source '{source_to_check.name}' \n- Id {source_to_check.id} \n- Trigger '{source_to_check.trigger[:30]}'", conflicting_source_id=source_to_check.id)