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

letschatty/models/ai_microservices/__init__.py

@@ -1,8 +1,8 @@
 from .expected_output import ExpectedOutputQualityTest, ExpectedOutputSmartTag
 from .lambda_events import (
-    IncomingMessageAIDecision, QualityTestCallbackEvent, SmartTaggingCallbackEvent,
-    QualityTestInteractionCallbackEvent, QualityTestEvent,
-    AllQualityTestEvent, SmartTaggingEvent, QualityTestEventData, AllQualityTestEventData,ChatData,
+    IncomingMessageCallbackEvent, QualityTestCallbackEvent, SmartTaggingCallbackEvent,
+    QualityTestInteractionCallbackEvent, IncomingMessageEvent, QualityTestEvent,
+    AllQualityTestEvent, FollowUpEvent, SmartTaggingEvent, QualityTestEventData, AllQualityTestEventData,ChatData,
     ComparisonAnalysisCallbackMetadata, InteractionCallbackMetadata, SmartTaggingCallbackMetadata,
     SmartTaggingPromptEvent
 )

letschatty/models/ai_microservices/expected_output.py

@@ -27,6 +27,20 @@ class ExpectedOutputSmartTag(BaseModel):
     chain_of_thought: ChainOfThoughtInChatRequest = Field(
         description="REQUIRED: Your reasoning process and response decision explanation"
     )
+    # Unsubscribe intent detection (for launch agents)
+    unsubscribe_intent: bool = Field(
+        default=False,
+        description="True if user expressed intent to unsubscribe from communications (e.g., 'no more messages', 'unsubscribe', 'stop', 'rechazar mensajes')"
+    )
+    # Acceptance criteria evaluation (for agents with data collection + acceptance_criteria)
+    acceptance_criteria_met: Optional[bool] = Field(
+        default=None,
+        description="True if user meets acceptance criteria, False if not, None if cannot be determined yet or no criteria configured"
+    )
+    acceptance_criteria_reason: Optional[str] = Field(
+        default=None,
+        description="Reason explaining why acceptance criteria is met or not met"
+    )
 
     @staticmethod
     def get_json_schema() -> dict:
@@ -100,9 +114,21 @@ class ExpectedOutputSmartTag(BaseModel):
                     },
                     "required": ["trigger", "trigger_id", "chatty_ai_agent_id", "chain_of_thought", "title"],
                     "additionalProperties": False
+                },
+                "unsubscribe_intent": {
+                    "type": "boolean",
+                    "description": "True if user expressed intent to unsubscribe from communications (e.g., 'no more messages', 'unsubscribe', 'stop', 'rechazar mensajes')"
+                },
+                "acceptance_criteria_met": {
+                    "anyOf": [{"type": "boolean"}, {"type": "null"}],
+                    "description": "True if user meets acceptance criteria, False if not, null if cannot be determined yet"
+                },
+                "acceptance_criteria_reason": {
+                    "anyOf": [{"type": "string"}, {"type": "null"}],
+                    "description": "Reason explaining why acceptance criteria is met or not met"
                 }
             },
-            "required": ["automation", "conversation_topics", "data_collection", "chain_of_thought"],
+            "required": ["automation", "conversation_topics", "data_collection", "chain_of_thought", "unsubscribe_intent", "acceptance_criteria_met", "acceptance_criteria_reason"],
             "additionalProperties": False
         }
 
@@ -143,6 +169,12 @@ class ExpectedOutputIncomingMessage(BaseModel):
     action: IncomingMessageDecisionAction
     messages: List[str] = Field(description="Array of message strings to send to the customer. Required for send/suggest actions, optional for escalate action, empty array for skip/remove actions.")
     chain_of_thought: ChainOfThoughtInChatRequest = Field(description="REQUIRED: Your reasoning process and response decision explanation")
+    confidence: Optional[int] = Field(
+        default=None,
+        ge=0,
+        le=100,
+        description="Confidence level 0-100"
+    )
 
     def to_incoming_message_decision_output(self) -> IncomingMessageAIDecision:
         messages_drafts = [
@@ -161,3 +193,5 @@ class ExpectedOutputIncomingMessage(BaseModel):
         return incoming_decision
 
 
+class ExpectedOutputSmartFollowUp(BaseModel):
+    action: Optional[str] = None

letschatty/models/ai_microservices/lambda_events.py

@@ -1,18 +1,17 @@
-from letschatty.models.company.assets.ai_agents_v2.chatty_ai_agent_in_chat import HumanInterventionReason
 from letschatty.models.company.assets.chat_assets import ChainOfThoughtInChatTrigger
 from pydantic import BaseModel, Field, model_validator
-from typing import Dict, Any, List, Optional, TYPE_CHECKING
+from typing import Dict, Any, List, Optional
 
 from letschatty.models.base_models.ai_agent_component import AiAgentComponentType
 from letschatty.models.utils.types.identifier import StrObjectId
 from .lambda_invokation_types import InvokationType, LambdaAiEvent
-from .expected_output import ExpectedOutputIncomingMessage, ExpectedOutputSmartTag, ExpectedOutputQualityTest, IncomingMessageAIDecision
-from ...models.company.assets.ai_agents_v2.ai_agents_decision_output import IncomingMessageDecisionAction, SmartFollowUpDecision
+from .expected_output import ExpectedOutputIncomingMessage, ExpectedOutputSmartTag, ExpectedOutputQualityTest, ExpectedOutputSmartFollowUp, IncomingMessageAIDecision
+from ...models.company.assets.ai_agents_v2.ai_agents_decision_output import IncomingMessageDecisionAction
+from ...models.company.assets.ai_agents_v2.chatty_ai_agent_in_chat import HumanInterventionReason
 
 class SmartTaggingCallbackMetadata(BaseModel):
     chat_id: StrObjectId
     company_id: StrObjectId
-    trigger: ChainOfThoughtInChatTrigger
 
 class ComparisonAnalysisCallbackMetadata(BaseModel):
     test_case_id: StrObjectId
@@ -24,7 +23,21 @@ class InteractionCallbackMetadata(BaseModel):
     ai_agent_id: StrObjectId
     company_id: StrObjectId
     interaction_index: int
-    trigger: ChainOfThoughtInChatTrigger
+
+class IncomingMessageCallbackMetadata(BaseModel):
+    chat_id: StrObjectId
+    company_id: StrObjectId
+    ai_agent_id: StrObjectId
+    cot_id: StrObjectId
+    trigger: str
+    # Trigger info is in: incoming_message_ids for user_message,
+    # triggered_by_user_id for manual_trigger, smart_follow_up_id for follow_up
+    triggered_by_user_id: Optional[StrObjectId] = None
+
+class IncomingMessageCallbackEvent(LambdaAiEvent):
+    type: InvokationType = InvokationType.INCOMING_MESSAGE_CALLBACK
+    data: IncomingMessageAIDecision
+    callback_metadata: IncomingMessageCallbackMetadata
 
 class QualityTestCallbackEvent(LambdaAiEvent):
     type: InvokationType = InvokationType.SINGLE_QUALITY_TEST_CALLBACK
@@ -48,15 +61,41 @@ class SmartTaggingCallbackEvent(LambdaAiEvent):
     callback_metadata: SmartTaggingCallbackMetadata
 
     @model_validator(mode="before")
-    def validate_data(cls, data):
-        if isinstance(data, dict) and "data" in data and "chain_of_thought" in data["data"]:
-                data["data"]["chain_of_thought"]["chatty_ai_agent_id"] = "000000000000000000000000"
-        return data
+    def normalize_data(cls, values):
+        if not isinstance(values, dict):
+            return values
+
+        data = values.get("data")
+        if isinstance(data, str):
+            import json
+            try:
+                data = json.loads(data)
+                values["data"] = data
+            except (json.JSONDecodeError, TypeError):
+                return values
+
+        if isinstance(data, dict) and "chain_of_thought" in data:
+            data["chain_of_thought"]["chatty_ai_agent_id"] = "000000000000000000000000"
+
+        return values
 
 class ChatData(BaseModel):
     chat_id: StrObjectId
     company_id: StrObjectId
 
+class IncomingMessageEvent(LambdaAiEvent):
+    type: InvokationType = InvokationType.INCOMING_MESSAGE
+    data: ChatData
+
+class FollowUpEvent(LambdaAiEvent):
+    type: InvokationType = InvokationType.FOLLOW_UP
+    data: ChatData
+
+
+class SmartFollowUpDecisionOutputEvent(LambdaAiEvent):
+    type: InvokationType = InvokationType.FOLLOW_UP
+    data: ExpectedOutputSmartFollowUp
+
 class QualityTestEventData(BaseModel):
     chat_example_id: StrObjectId
     company_id: StrObjectId
@@ -111,7 +150,7 @@ class DoubleCheckerCallbackMetadata(BaseModel):
     ai_agent_id: StrObjectId
     incoming_messages_ids: List[str]
     # Trigger info
-    trigger: ChainOfThoughtInChatTrigger
+    trigger: str
     # Trigger info is in: incoming_messages_ids for user_message,
     # triggered_by_user_id for manual_trigger, smart_follow_up_id for follow_up
     triggered_by_user_id: Optional[StrObjectId] = None
@@ -131,27 +170,6 @@ class DoubleCheckerForIncomingMessagesAnswerCallbackMetadata(BaseModel):
     ai_agent_id: StrObjectId
 
 
-# Smart Follow-Up Decision Output Events
-
-class SmartFollowUpDecisionOutputData(BaseModel):
-    """Data for smart follow-up decision output"""
-    chat_id: StrObjectId
-    company_id: StrObjectId
-    ai_agent_id: StrObjectId
-    smart_follow_up_decision: 'SmartFollowUpDecision'
-    smart_follow_up_id: Optional[StrObjectId] = None
-
-class SmartFollowUpDecisionOutputEvent(LambdaAiEvent):
-    """
-    Event for smart follow-up decision output.
-
-    Similar to incoming message decision but for follow-ups.
-    Bypasses double checker and sends directly to API.
-    """
-    type: InvokationType = InvokationType.SMART_FOLLOW_UP_DECISION_OUTPUT
-    data: SmartFollowUpDecisionOutputData
-
-
 # New AI Agent Context Building Events (for new architecture)
 
 class GetChatWithPromptForIncomingMessageEventData(BaseModel):
@@ -184,7 +202,7 @@ class GetChatWithPromptForFollowUpEventData(BaseModel):
     """Data for get chat with prompt for follow-up event"""
     chat_id: StrObjectId
     company_id: StrObjectId
-    smart_follow_up_id: Optional[StrObjectId] = Field(default=None, description="Smart follow-up ID")
+    smart_follow_up_id: StrObjectId
     # Trigger information
     trigger: ChainOfThoughtInChatTrigger
     # trigger_id is derived from: smart_follow_up_id
@@ -304,8 +322,8 @@ class EscalateAIAgentInChatEventData(BaseModel):
     """Data for escalating an AI agent (requiring human intervention)"""
     chat_id: StrObjectId
     company_id: StrObjectId
-    reason: HumanInterventionReason = Field(description="Reason for escalation", default=HumanInterventionReason.SOMETHING_WENT_WRONG)
-    message: Optional[str] = Field(default="El agente de IA requiere de tu intervención", description="The message to display to the user if any")
+    reason: str = Field(description="Reason for escalation (e.g., 'Complex technical issue', 'Customer request')")
+
 
 class EscalateAIAgentInChatEvent(LambdaAiEvent):
     """
@@ -336,21 +354,43 @@ class UnescalateAIAgentInChatEvent(LambdaAiEvent):
     data: UnescalateAIAgentInChatEventData
 
 
+# Launch Events
+
+class LaunchCommunicationEventData(BaseModel):
+    """Data for sending a scheduled launch communication"""
+    chat_ids: List[StrObjectId] = Field(description="Batch of chat IDs to send communication to")
+    company_id: StrObjectId
+    launch_id: StrObjectId
+    communication_id: str = Field(description="ID of the communication within the launch")
+    communication_type: str = Field(description="Type: pre_launch, post_attended, post_missed, welcome_kit")
+    lambda_callback_url: str = Field(description="URL for Lambda to call back after N8N processing")
+
+
+class LaunchCommunicationEvent(LambdaAiEvent):
+    """
+    Event to send a scheduled launch communication.
+
+    Triggered by Copilot when delta_minutes is reached. Lambda processes
+    the batch of chats, building context for each and sending to N8N
+    for AI adaptation (or sending literal messages directly).
+    """
+    type: InvokationType = InvokationType.LAUNCH_COMMUNICATION
+    data: LaunchCommunicationEventData
+
 
-class GetChainOfThoughtsByChatIdEventData(BaseModel):
-    """Data for getting chain of thoughts by chat ID"""
+class LaunchWelcomeKitEventData(BaseModel):
+    """Data for sending a welcome kit with AI adaptation"""
     chat_id: StrObjectId
     company_id: StrObjectId
-    skip: int = Field(default=0, description="Number of results to skip for pagination")
-    limit: int = Field(default=10, description="Number of results to return")
+    launch_id: StrObjectId
 
 
-class GetChainOfThoughtsByChatIdEvent(LambdaAiEvent):
+class LaunchWelcomeKitEvent(LambdaAiEvent):
     """
-    Event to get chain of thoughts for a chat.
+    Event to send a welcome kit with AI adaptation.
 
-    Returns a list of chain of thoughts associated with the given chat ID,
-    sorted by created_at (newest first), with pagination support via skip.
+    Triggered when a user subscribes to a launch and the welcome kit
+    requires AI adaptation. Lambda builds context and sends to N8N.
     """
-    type: InvokationType = InvokationType.GET_CHAIN_OF_THOUGHTS_BY_CHAT_ID
-    data: GetChainOfThoughtsByChatIdEventData
+    type: InvokationType = InvokationType.LAUNCH_WELCOME_KIT
+    data: LaunchWelcomeKitEventData

letschatty/models/ai_microservices/lambda_invokation_types.py

@@ -3,20 +3,21 @@ from enum import StrEnum
 from pydantic import BaseModel
 
 class InvokationType(StrEnum):
+    INCOMING_MESSAGE = "incoming_message"
+    FOLLOW_UP = "follow_up"
     SINGLE_QUALITY_TEST = "single_quality_test"
     ALL_QUALITY_TEST = "all_quality_test"
     SMART_TAGGING = "smart_tagging"
     SMART_TAGGING_PROMPT = "smart_tagging_prompt"
     QUALITY_TEST_INTERACTION = "quality_test_interaction"
     # Callback-specific types
+    INCOMING_MESSAGE_CALLBACK = "incoming_message_callback"
     SINGLE_QUALITY_TEST_CALLBACK = "single_quality_test_callback"
     SMART_TAGGING_CALLBACK = "smart_tagging_callback"
     QUALITY_TESTS_FOR_UPDATED_AI_COMPONENT = "quality_tests_for_updated_ai_component"
     FIX_BUGGED_AI_AGENTS_CALLS_IN_CHATS = "fix_bugged_ai_agents_calls_in_chats"
     DOUBLE_CHECKER_FOR_INCOMING_MESSAGES_ANSWER = "double_checker_for_incoming_messages_answer"
     DOUBLE_CHECKER_FOR_INCOMING_MESSAGES_ANSWER_CALLBACK = "double_checker_for_incoming_messages_answer_callback"
-    # Decision output events
-    SMART_FOLLOW_UP_DECISION_OUTPUT = "smart_follow_up_decision_output"
     # AI Agent context building events (new architecture)
     GET_CHAT_WITH_PROMPT_INCOMING_MESSAGE = "get_chat_with_prompt_incoming_message"
     GET_CHAT_WITH_PROMPT_FOLLOW_UP = "get_chat_with_prompt_follow_up"
@@ -29,7 +30,9 @@ class InvokationType(StrEnum):
     UPDATE_AI_AGENT_MODE_IN_CHAT = "update_ai_agent_mode_in_chat"
     ESCALATE_AI_AGENT_IN_CHAT = "escalate_ai_agent_in_chat"
     UNESCALATE_AI_AGENT_IN_CHAT = "unescalate_ai_agent_in_chat"
-    GET_CHAIN_OF_THOUGHTS_BY_CHAT_ID = "get_chain_of_thoughts_by_chat_id"
+    # Launch events
+    LAUNCH_COMMUNICATION = "launch_communication"
+    LAUNCH_WELCOME_KIT = "launch_welcome_kit"
 
 class LambdaAiEvent(BaseModel):
     type: InvokationType

letschatty/models/analytics/events/__init__.py

@@ -4,7 +4,7 @@ from .chat_based_events.business_area import ChatBusinessAreaEvent, BusinessArea
 from .chat_based_events.workflow import WorkflowEvent, WorkflowEventData
 from .chat_based_events.chat_status import ChatStatusEvent, ChatStatusEventData, ChatStatusModification, ChatCreatedFrom
 from .chat_based_events.chat_funnel import ChatFunnelEvent, FunnelEventData
-from ...company.CRM.funnel import ClientFunnel, StageTransition
+from ...company.CRM.funnel import ChatFunnel, StageTransition, ActiveFunnel
 from .company_based_events.user_events import UserEvent, UserEventData
 from .chat_based_events.quality_scoring import QualityScoringEvent
 from .chat_based_events.message import MessageEvent, MessageData
@@ -28,5 +28,4 @@ from ...messages.chatty_messages import ChattyMessage
 from ...company.CRM.funnel import Funnel, FunnelStage
 from ...utils.types import Status
 from .chat_based_events.chat_based_event import CustomerEventData
-from .chat_based_events.ai_agent_chat import ChattyAIChatEvent, ChattyAIChatData
-from .chat_based_events.ai_agent_execution_event import AIAgentExecutionEvent, AIAgentExecutionEventData
+from .chat_based_events.ai_agent_chat import ChattyAIChatEvent, ChattyAIChatData

letschatty/models/analytics/events/chat_based_events/chat_funnel.py

@@ -4,37 +4,93 @@ from ..base import Event
 from ..event_types import EventType
 from .chat_based_event import CustomerEventData
 from ....utils.types.identifier import StrObjectId
-from ....company.CRM.funnel import ClientFunnel, StageTransition
+from ....company.CRM.funnel import StageTransition
 import json
 
+
 class FunnelEventData(CustomerEventData):
-    funnel_id: StrObjectId
-    funnel_stage_transition: StageTransition
-    time_in_funnel_seconds: Optional[int] = None
+    """
+    Event data for chat funnel events.
+    
+    Fields required per event type:
+    - STARTED: funnel_id, chat_funnel_id, stage_transition
+    - STAGE_CHANGED: funnel_id, chat_funnel_id, stage_transition (with time_in_previous_stage_seconds)
+    - COMPLETED: funnel_id, chat_funnel_id, time_in_funnel_seconds, time_in_last_stage_seconds
+    - ABANDONED: funnel_id, chat_funnel_id, time_in_funnel_seconds, time_in_last_stage_seconds
+    """
+    funnel_id: StrObjectId = Field(description="The funnel the chat is in")
+    chat_funnel_id: StrObjectId = Field(description="Reference to the ChatFunnel record")
+    
+    # For STARTED and STAGE_CHANGED events
+    stage_transition: Optional[StageTransition] = Field(
+        default=None,
+        description="The stage transition details (for STARTED and STAGE_CHANGED)"
+    )
+    
+    # For COMPLETED and ABANDONED events
+    time_in_funnel_seconds: Optional[int] = Field(
+        default=None,
+        description="Total time spent in the funnel (for COMPLETED and ABANDONED)"
+    )
+    time_in_last_stage_seconds: Optional[int] = Field(
+        default=None,
+        description="Time spent in the last stage before completion/abandonment"
+    )
+
 
 class ChatFunnelEvent(Event):
-    """Event for tracking chat funnel stage transitions"""
+    """
+    Event for tracking chat funnel lifecycle.
+    
+    Events:
+    - CHAT_FUNNEL_STARTED: Chat entered a funnel
+    - CHAT_FUNNEL_STAGE_CHANGED: Chat moved between stages
+    - CHAT_FUNNEL_COMPLETED: Chat completed the funnel
+    - CHAT_FUNNEL_ABANDONED: Chat abandoned the funnel
+    """
     data: FunnelEventData
 
-    # Define valid event types for this event class
     VALID_TYPES: ClassVar[set] = {
-        EventType.CHAT_FUNNEL_UPDATED,
         EventType.CHAT_FUNNEL_STARTED,
+        EventType.CHAT_FUNNEL_STAGE_CHANGED,
         EventType.CHAT_FUNNEL_COMPLETED,
         EventType.CHAT_FUNNEL_ABANDONED
     }
 
-
     @field_validator('data')
     def validate_data_fields(cls, v: FunnelEventData, info: ValidationInfo):
         """Validate that appropriate fields are set based on event type"""
-        if info.data.get('type') == EventType.CHAT_FUNNEL_UPDATED and v.time_in_funnel_seconds is None:
-            raise ValueError("time_in_funnel_seconds must be set for CHAT_FUNNEL_UPDATED events")
-        if info.data.get('type') == EventType.CHAT_FUNNEL_UPDATED and v.funnel_stage_transition.time_in_previous_stage_seconds is None:
-            raise ValueError("time_in_previous_stage_seconds must be set for CHAT_FUNNEL_UPDATED events")
+        event_type = info.data.get('type')
+        
+        # STARTED: requires stage_transition
+        if event_type == EventType.CHAT_FUNNEL_STARTED:
+            if v.stage_transition is None:
+                raise ValueError("stage_transition must be set for CHAT_FUNNEL_STARTED events")
+        
+        # STAGE_CHANGED: requires stage_transition with time_in_previous_stage_seconds
+        elif event_type == EventType.CHAT_FUNNEL_STAGE_CHANGED:
+            if v.stage_transition is None:
+                raise ValueError("stage_transition must be set for CHAT_FUNNEL_STAGE_CHANGED events")
+            if v.stage_transition.time_in_previous_stage_seconds is None:
+                raise ValueError("time_in_previous_stage_seconds must be set in stage_transition for CHAT_FUNNEL_STAGE_CHANGED events")
+        
+        # COMPLETED: requires time metrics
+        elif event_type == EventType.CHAT_FUNNEL_COMPLETED:
+            if v.time_in_funnel_seconds is None:
+                raise ValueError("time_in_funnel_seconds must be set for CHAT_FUNNEL_COMPLETED events")
+            if v.time_in_last_stage_seconds is None:
+                raise ValueError("time_in_last_stage_seconds must be set for CHAT_FUNNEL_COMPLETED events")
+        
+        # ABANDONED: requires time metrics
+        elif event_type == EventType.CHAT_FUNNEL_ABANDONED:
+            if v.time_in_funnel_seconds is None:
+                raise ValueError("time_in_funnel_seconds must be set for CHAT_FUNNEL_ABANDONED events")
+            if v.time_in_last_stage_seconds is None:
+                raise ValueError("time_in_last_stage_seconds must be set for CHAT_FUNNEL_ABANDONED events")
+        
         return v
 
     def model_dump_json(self, *args, **kwargs):
         dump = json.loads(super().model_dump_json(*args, **kwargs))
         dump['data'] = self.data.model_dump_json()
-        return dump
+        return dump

letschatty/models/analytics/events/company_based_events/asset_events.py

@@ -58,6 +58,9 @@ class AssetEvent(Event):
         EventType.FUNNEL_STAGE_CREATED,
         EventType.FUNNEL_STAGE_UPDATED,
         EventType.FUNNEL_STAGE_DELETED,
+        EventType.FUNNEL_MEMBER_ADDED,
+        EventType.FUNNEL_MEMBER_UPDATED,
+        EventType.FUNNEL_MEMBER_REMOVED,
         EventType.WORKFLOW_CREATED,
         EventType.WORKFLOW_UPDATED,
         EventType.WORKFLOW_DELETED,
@@ -70,6 +73,9 @@ class AssetEvent(Event):
         EventType.FILTER_CRITERIA_CREATED,
         EventType.FILTER_CRITERIA_UPDATED,
         EventType.FILTER_CRITERIA_DELETED,
+        EventType.FORM_FIELD_CREATED,
+        EventType.FORM_FIELD_UPDATED,
+        EventType.FORM_FIELD_DELETED,
         EventType.COMPANY_CREATED,
         EventType.COMPANY_UPDATED,
         EventType.COMPANY_DELETED
@@ -77,8 +83,9 @@ class AssetEvent(Event):
 
     @model_validator(mode='after')
     def validate_data_fields(self):
-        if "deleted" not in self.type.value and not self.data.asset:
-            raise ValueError("asset must be set for all events except DELETED")
+        # Asset is not required for deleted/removed events
+        if "deleted" not in self.type.value and "removed" not in self.type.value and not self.data.asset:
+            raise ValueError("asset must be set for all events except DELETED/REMOVED")
         return self
 
     def model_dump_json(self, *args, **kwargs):

letschatty/models/analytics/events/event_type_to_classes.py

@@ -41,10 +41,9 @@ EVENT_TO_TYPE_CLASSES = {
     #CONTINUOUS CONVERSATION
     EventType.CONTINUOUS_CONVERSATION_CREATED : ContinuousConversationEvent,
     EventType.CONTINUOUS_CONVERSATION_UPDATED : ContinuousConversationEvent,
-    #FUNNEL STAGES
-    # Funnel-level events
+    #CHAT FUNNEL EVENTS
     EventType.CHAT_FUNNEL_STARTED : ChatFunnelEvent,
-    EventType.CHAT_FUNNEL_UPDATED : ChatFunnelEvent,
+    EventType.CHAT_FUNNEL_STAGE_CHANGED : ChatFunnelEvent,
     EventType.CHAT_FUNNEL_COMPLETED : ChatFunnelEvent,
     EventType.CHAT_FUNNEL_ABANDONED : ChatFunnelEvent,
 
@@ -86,6 +85,10 @@ EVENT_TO_TYPE_CLASSES = {
     EventType.WORKFLOW_CREATED : AssetEvent,
     EventType.WORKFLOW_UPDATED : AssetEvent,
     EventType.WORKFLOW_DELETED : AssetEvent,
+    #FORM FIELDS
+    EventType.FORM_FIELD_CREATED : AssetEvent,
+    EventType.FORM_FIELD_UPDATED : AssetEvent,
+    EventType.FORM_FIELD_DELETED : AssetEvent,
     #AGENTS
     EventType.USER_CREATED : UserEvent,
     EventType.USER_UPDATED : UserEvent,

letschatty/models/analytics/events/event_types.py

@@ -12,51 +12,6 @@ class EventType(StrEnum):
     AI_AGENT_ASSIGNED_TO_CHAT = "chat.chatty_ai_agent.assigned_to_chat"
     AI_AGENT_REMOVED_FROM_CHAT = "chat.chatty_ai_agent.removed_from_chat"
     AI_AGENT_UPDATED_ON_CHAT = "chat.chatty_ai_agent.updated_on_chat"
-
-    #CHATTY AI AGENT EXECUTION EVENTS - 3-level hierarchy for execution tracking
-    # Pattern: chatty_ai_agent_in_chat.{operation}.{detail}
-    # Note: Execution events are already chat-scoped via CustomerEventData
-
-    # TRIGGER EVENTS - What initiates AI agent processing
-    CHATTY_AI_AGENT_IN_CHAT_TRIGGER_USER_MESSAGE = "chatty_ai_agent_in_chat.trigger.user_message"
-    CHATTY_AI_AGENT_IN_CHAT_TRIGGER_FOLLOW_UP = "chatty_ai_agent_in_chat.trigger.follow_up"
-    CHATTY_AI_AGENT_IN_CHAT_TRIGGER_MANUAL = "chatty_ai_agent_in_chat.trigger.manual"
-    CHATTY_AI_AGENT_IN_CHAT_TRIGGER_RETRY = "chatty_ai_agent_in_chat.trigger.retry"
-
-    # STATE EVENTS - AI agent state changes
-    CHATTY_AI_AGENT_IN_CHAT_STATE_PROCESSING_STARTED = "chatty_ai_agent_in_chat.state.processing_started"
-    CHATTY_AI_AGENT_IN_CHAT_STATE_CALL_STARTED = "chatty_ai_agent_in_chat.state.call_started"
-    CHATTY_AI_AGENT_IN_CHAT_STATE_ESCALATED = "chatty_ai_agent_in_chat.state.escalated"
-    CHATTY_AI_AGENT_IN_CHAT_STATE_UNESCALATED = "chatty_ai_agent_in_chat.state.unescalated"
-
-    # CALL EVENTS - Outbound calls to services
-    CHATTY_AI_AGENT_IN_CHAT_CALL_GET_CHAT_WITH_PROMPT = "chatty_ai_agent_in_chat.call.get_chat_with_prompt"
-    CHATTY_AI_AGENT_IN_CHAT_CALL_TAGGER = "chatty_ai_agent_in_chat.call.tagger"
-    CHATTY_AI_AGENT_IN_CHAT_CALL_DOUBLE_CHECKER = "chatty_ai_agent_in_chat.call.double_checker"
-    CHATTY_AI_AGENT_IN_CHAT_CALL_DEBUGGER = "chatty_ai_agent_in_chat.call.debugger"
-
-    # CALLBACK EVENTS - Responses received from services
-    CHATTY_AI_AGENT_IN_CHAT_CALLBACK_GET_CHAT_WITH_PROMPT = "chatty_ai_agent_in_chat.callback.get_chat_with_prompt"
-    CHATTY_AI_AGENT_IN_CHAT_CALLBACK_TAGGER = "chatty_ai_agent_in_chat.callback.tagger"
-    CHATTY_AI_AGENT_IN_CHAT_CALLBACK_DOUBLE_CHECKER = "chatty_ai_agent_in_chat.callback.double_checker"
-    CHATTY_AI_AGENT_IN_CHAT_CALLBACK_OUTPUT_RECEIVED = "chatty_ai_agent_in_chat.callback.output_received"
-
-    # DECISION EVENTS - AI agent decisions and actions
-    CHATTY_AI_AGENT_IN_CHAT_DECISION_SEND = "chatty_ai_agent_in_chat.decision.send"
-    CHATTY_AI_AGENT_IN_CHAT_DECISION_SUGGEST = "chatty_ai_agent_in_chat.decision.suggest"
-    CHATTY_AI_AGENT_IN_CHAT_DECISION_ESCALATE = "chatty_ai_agent_in_chat.decision.escalate"
-    CHATTY_AI_AGENT_IN_CHAT_DECISION_SKIP = "chatty_ai_agent_in_chat.decision.skip"
-    CHATTY_AI_AGENT_IN_CHAT_DECISION_SENT_TO_API = "chatty_ai_agent_in_chat.decision.sent_to_api"
-    CHATTY_AI_AGENT_IN_CHAT_DECISION_COMPLETED = "chatty_ai_agent_in_chat.decision.completed"
-
-    # ERROR EVENTS - Failures and cancellations
-    CHATTY_AI_AGENT_IN_CHAT_ERROR_CALL_FAILED = "chatty_ai_agent_in_chat.error.call_failed"
-    CHATTY_AI_AGENT_IN_CHAT_ERROR_CALL_CANCELLED = "chatty_ai_agent_in_chat.error.call_cancelled"
-    CHATTY_AI_AGENT_IN_CHAT_ERROR_VALIDATION_FAILED = "chatty_ai_agent_in_chat.error.validation_failed"
-
-    # RATING EVENTS - User feedback
-    CHATTY_AI_AGENT_IN_CHAT_RATING_RECEIVED = "chatty_ai_agent_in_chat.rating.received"
-
     #PRODUCTS
     PRODUCT_ASSIGNED = "chat.product.assigned"
     PRODUCT_REMOVED = "chat.product.removed"
@@ -87,10 +42,9 @@ class EventType(StrEnum):
     #CONTINUOUS CONVERSATION
     CONTINUOUS_CONVERSATION_CREATED = "chat.continuous_conversation.created"
     CONTINUOUS_CONVERSATION_UPDATED = "chat.continuous_conversation.updated"
-    #FUNNEL STAGES
-    # Funnel-level events
-    CHAT_FUNNEL_STARTED = "chat.funnel.started"  # New
-    CHAT_FUNNEL_UPDATED = "chat.funnel.updated"
+    #CHAT FUNNEL EVENTS
+    CHAT_FUNNEL_STARTED = "chat.funnel.started"
+    CHAT_FUNNEL_STAGE_CHANGED = "chat.funnel.stage_changed"
     CHAT_FUNNEL_COMPLETED = "chat.funnel.completed"
     CHAT_FUNNEL_ABANDONED = "chat.funnel.abandoned"
 
@@ -129,13 +83,18 @@ class EventType(StrEnum):
     FAST_ANSWER_CREATED = "company.fast_answer.created"
     FAST_ANSWER_UPDATED = "company.fast_answer.updated"
     FAST_ANSWER_DELETED = "company.fast_answer.deleted"
-    #FUNNEL STAGES
+    #FUNNELS
     FUNNEL_CREATED = "company.funnel.created"
     FUNNEL_UPDATED = "company.funnel.updated"
     FUNNEL_DELETED = "company.funnel.deleted"
+    #FUNNEL STAGES
     FUNNEL_STAGE_CREATED = "company.funnel_stage.created"
     FUNNEL_STAGE_UPDATED = "company.funnel_stage.updated"
     FUNNEL_STAGE_DELETED = "company.funnel_stage.deleted"
+    #FUNNEL MEMBERS
+    FUNNEL_MEMBER_ADDED = "company.funnel_member.added"
+    FUNNEL_MEMBER_UPDATED = "company.funnel_member.updated"
+    FUNNEL_MEMBER_REMOVED = "company.funnel_member.removed"
     #BUSINESS AREA
     BUSINESS_AREA_CREATED = "company.business_area.created"
     BUSINESS_AREA_UPDATED = "company.business_area.updated"
@@ -163,3 +122,7 @@ class EventType(StrEnum):
     FILTER_CRITERIA_CREATED = "company.filter_criteria.created"
     FILTER_CRITERIA_UPDATED = "company.filter_criteria.updated"
     FILTER_CRITERIA_DELETED = "company.filter_criteria.deleted"
+    #FORM FIELDS
+    FORM_FIELD_CREATED = "company.form_field.created"
+    FORM_FIELD_UPDATED = "company.form_field.updated"
+    FORM_FIELD_DELETED = "company.form_field.deleted"

letschatty/models/chat/chat.py

@@ -19,6 +19,7 @@ from ..utils.custom_exceptions.custom_exceptions import MissingAIAgentForSmartFo
 from .time_left import TimeLeft
 from ..company.conversation_topic import TopicTimelineEntry
 from ..company.form_field import CollectedData
+from ..company.CRM.funnel import ActiveFunnel
 import json
 import logging
 logger = logging.getLogger(__name__)
@@ -47,6 +48,7 @@ class Chat(CompanyAssetModel):
     chatty_ai_agent: Optional[ChattyAIAgentAssignedToChat] = Field(default=None, description="The id of the chatty ai agent that might or might not be assigned to the chat")
     suggested_messages: List[MessageDraft] = Field(default_factory=list)
     topics_timeline: List[TopicTimelineEntry] = Field(default_factory=list, description="Timeline of conversation topics throughout the conversation")
+    active_funnel: Optional[ActiveFunnel] = Field(default=None, description="Current active funnel for this chat")
     model_config = ConfigDict(extra="ignore")
 
     @property
@@ -139,6 +141,7 @@ class Chat(CompanyAssetModel):
     @property
     def assigned_chatty_ai_agent(self) -> ChattyAIAgentAssignedToChat:
         """Get the assigned chatty ai agent"""
+        raise DeprecationWarning("This method is not implemented anymore")
         if self.chatty_ai_agent is None:
             raise MissingAIAgentForSmartFollowUp(f"Chat {self.id} has no chatty ai agent assigned to it")
         return self.chatty_ai_agent
@@ -266,7 +269,17 @@ class Chat(CompanyAssetModel):
     @property
     def bought_product_ids(self) -> List[StrObjectId]:
         """Get all sale ids in the chat"""
-        return [sale.product_id for sale in self.sales]
+        product_ids: List[StrObjectId] = []
+        for sale in self.sales:
+            sale_product_ids = getattr(sale, "product_ids", None)
+            if sale_product_ids:
+                for product_id in sale_product_ids:
+                    if product_id not in product_ids:
+                        product_ids.append(product_id)
+            elif sale.product_id:
+                if sale.product_id not in product_ids:
+                    product_ids.append(sale.product_id)
+        return product_ids
 
     @property
     def products(self) -> List[AssignedAssetToChat]:
@@ -363,4 +376,3 @@ class Chat(CompanyAssetModel):
             dump["last_message"] = self.last_message.model_dump_json(serializer=SerializerType.DATABASE) if self.last_message else None
             dump["flow_states"] = [flow_state.model_dump_json(serializer=SerializerType.DATABASE) for flow_state in self.flow_states]
         return dump
-

letschatty/models/chat/chat_with_assets.py

@@ -1,6 +1,6 @@
-
 from .chat import Chat
 from letschatty.models.company.assets import TagPreview, FlowPreview, ContactPoint, Sale, ChattyAIAgentPreview, ProductPreview
+from letschatty.models.company.CRM.funnel import ActiveFunnel
 
 from letschatty.models.utils.types.serializer_type import SerializerType
 from pydantic import BaseModel
@@ -15,3 +15,8 @@ class ChatWithAssets(BaseModel):
     contact_points: List[ContactPoint]
     flows_links_states: List[FlowPreview]
     chatty_ai_agent: Optional[ChattyAIAgentPreview]
+
+    @property
+    def active_funnel(self) -> Optional[ActiveFunnel]:
+        """Convenience property to access the chat's active funnel"""
+        return self.chat.active_funnel