letschatty 0.4.341__tar.gz → 0.4.342__tar.gz

{letschatty-0.4.341 → letschatty-0.4.342}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: letschatty
-Version: 0.4.341
+Version: 0.4.342
 Summary: Models and custom classes to work across the Chattyverse
 License: MIT
 Author: Axel

{letschatty-0.4.341 → letschatty-0.4.342}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "letschatty"
-version = "0.4.341"  # Or whichever is your latest version
+version = "0.4.342"  # Or whichever is your latest version
 description = "Models and custom classes to work across the Chattyverse"
 authors = ["Axel <axel@letschatty.com>"]
 license = "MIT"

letschatty-0.4.342/src/letschatty/models/ai_microservices/__init__.py

@@ -0,0 +1,10 @@
+from .expected_output import ExpectedOutputQualityTest, ExpectedOutputSmartTag
+from .lambda_events import (
+    IncomingMessageAIDecision, QualityTestCallbackEvent, SmartTaggingCallbackEvent,
+    QualityTestInteractionCallbackEvent, QualityTestEvent,
+    AllQualityTestEvent, SmartTaggingEvent, QualityTestEventData, AllQualityTestEventData,ChatData,
+    ComparisonAnalysisCallbackMetadata, InteractionCallbackMetadata, SmartTaggingCallbackMetadata,
+    SmartTaggingPromptEvent
+)
+from .lambda_invokation_types import InvokationType, LambdaAiEvent
+from .openai_payloads import OpenaiPayload, N8nPayload

{letschatty-0.4.341 → letschatty-0.4.342}/src/letschatty/models/ai_microservices/expected_output.py

@@ -6,9 +6,10 @@ from typing import List, Optional, Literal
 from datetime import datetime
 
 from letschatty.models.utils.types.message_types import MessageType
-from ...models.company.assets.ai_agents_v2.ai_agents_decision_output import ChainOfThoughtInChatRequest, IncomingMessageAIDecision, IncomingMessageDecisionAction
+from ...models.company.assets.ai_agents_v2.ai_agents_decision_output import ChainOfThoughtInChatRequest, IncomingMessageAIDecision, IncomingMessageDecisionAction, SmartFollowUpDecision, SmartFollowUpDecisionAction
 from ...models.company.assets.automation import Automation
 from ...models.company.form_field import CollectedData
+from ...models.chat.chat import Area
 
 class ExpectedOutputQualityTest(BaseModel):
     accuracy: float = Field(description="The accuracy of the comparison analysis")
@@ -194,4 +195,30 @@ class ExpectedOutputIncomingMessage(BaseModel):
 
 
 class ExpectedOutputSmartFollowUp(BaseModel):
-    action: Optional[str] = None
+    action: SmartFollowUpDecisionAction
+    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/postpone actions.")
+    chain_of_thought: ChainOfThoughtInChatRequest = Field(description="REQUIRED: Your reasoning process and response decision explanation")
+    next_call_time: Optional[datetime] = Field(default=None, description="The next call time for the smart follow up (required for postpone_delta_time action)")
+    reason: Optional[str] = Field(default=None, description="Reason for the decision (especially for postpone/postponed actions)")
+    area: Optional[Area] = Field(default=None, description="The area to move the chat after the decision")
+
+    def to_smart_follow_up_decision_output(self) -> SmartFollowUpDecision:
+        messages_drafts = [
+            MessageDraft(
+                type=MessageType.TEXT,
+                content=ChattyContentText(body=message),
+                is_incoming_message=False
+            )
+            for message in self.messages
+        ]
+        smart_follow_up_decision = SmartFollowUpDecision(
+            action=self.action,
+            next_call_time=self.next_call_time,
+            messages=messages_drafts,
+            chain_of_thought=self.chain_of_thought,
+            reason=self.reason,
+            area=self.area
+        )
+        return smart_follow_up_decision
+
+

{letschatty-0.4.341 → letschatty-0.4.342}/src/letschatty/models/ai_microservices/lambda_events.py

@@ -1,17 +1,18 @@
+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
+from typing import Dict, Any, List, Optional, TYPE_CHECKING
 
 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, 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
+from .expected_output import ExpectedOutputIncomingMessage, ExpectedOutputSmartFollowUp, ExpectedOutputSmartTag, ExpectedOutputQualityTest, IncomingMessageAIDecision
+from ...models.company.assets.ai_agents_v2.ai_agents_decision_output import IncomingMessageDecisionAction, SmartFollowUpDecision
 
 class SmartTaggingCallbackMetadata(BaseModel):
     chat_id: StrObjectId
     company_id: StrObjectId
+    trigger: ChainOfThoughtInChatTrigger
 
 class ComparisonAnalysisCallbackMetadata(BaseModel):
     test_case_id: StrObjectId
@@ -23,21 +24,8 @@ class InteractionCallbackMetadata(BaseModel):
     ai_agent_id: StrObjectId
     company_id: StrObjectId
     interaction_index: int
-
-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
+    trigger: ChainOfThoughtInChatTrigger
+    chain_of_thought_id: StrObjectId
 
 class QualityTestCallbackEvent(LambdaAiEvent):
     type: InvokationType = InvokationType.SINGLE_QUALITY_TEST_CALLBACK
@@ -55,6 +43,50 @@ class QualityTestInteractionCallbackEvent(LambdaAiEvent):
             data["data"]["chain_of_thought"]["chatty_ai_agent_id"] = data["callback_metadata"]["ai_agent_id"]
         return data
 
+    @model_validator(mode="before")
+    @classmethod
+    def set_chain_of_thought_id(cls, values: Dict[str, Any]):
+        """
+        Get the chain_of_thought_id from callback_metadata and set it in data.chain_of_thought.id
+
+        Handles both cases:
+        - data is a JSON string (needs parsing)
+        - data is already a dict
+        """
+        import json
+
+        data = values.get("data")
+        callback_metadata = values.get("callback_metadata")
+
+        if not data or not callback_metadata:
+            return values
+
+        # Get chain_of_thought_id from callback_metadata (could be dict or object)
+        if isinstance(callback_metadata, dict):
+            chain_of_thought_id = callback_metadata.get("chain_of_thought_id")
+        else:
+            chain_of_thought_id = getattr(callback_metadata, "chain_of_thought_id", None)
+
+        if not chain_of_thought_id:
+            return values
+
+        # Parse data if it's a JSON string
+        if isinstance(data, str):
+            try:
+                data = json.loads(data)
+                values["data"] = data
+            except (json.JSONDecodeError, TypeError):
+                return values
+
+        # If data is a dict, set the id in chain_of_thought
+        if isinstance(data, dict):
+            chain_of_thought = data.get("chain_of_thought")
+            if isinstance(chain_of_thought, dict):
+                chain_of_thought["id"] = chain_of_thought_id
+
+        return values
+
+
 class SmartTaggingCallbackEvent(LambdaAiEvent):
     type: InvokationType = InvokationType.SMART_TAGGING_CALLBACK
     data: ExpectedOutputSmartTag
@@ -149,11 +181,9 @@ class DoubleCheckerCallbackMetadata(BaseModel):
     company_id: StrObjectId
     ai_agent_id: StrObjectId
     incoming_messages_ids: List[str]
-    # Trigger info
-    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
+    trigger: ChainOfThoughtInChatTrigger
+    chain_of_thought_id: StrObjectId
+
 
 class DoubleCheckerForIncomingMessagesAnswerEvent(LambdaAiEvent):
     type: InvokationType = InvokationType.DOUBLE_CHECKER_FOR_INCOMING_MESSAGES_ANSWER
@@ -161,13 +191,73 @@ class DoubleCheckerForIncomingMessagesAnswerEvent(LambdaAiEvent):
 
 class DoubleCheckerForIncomingMessagesAnswerCallbackEvent(LambdaAiEvent):
     type: InvokationType = InvokationType.DOUBLE_CHECKER_FOR_INCOMING_MESSAGES_ANSWER_CALLBACK
-    data: DoubleCheckerForIncomingMessagesAnswerData
+    data: ExpectedOutputIncomingMessage
     callback_metadata: DoubleCheckerCallbackMetadata
 
-class DoubleCheckerForIncomingMessagesAnswerCallbackMetadata(BaseModel):
+    @model_validator(mode="before")
+    @classmethod
+    def set_chain_of_thought_id(cls, values: Dict[str, Any]):
+        """
+        Get the chain_of_thought_id from callback_metadata and set it in data.chain_of_thought.id
+
+        Handles both cases:
+        - data is a JSON string (needs parsing)
+        - data is already a dict
+        """
+        import json
+
+        data = values.get("data")
+        callback_metadata = values.get("callback_metadata")
+
+        if not data or not callback_metadata:
+            return values
+
+        # Get chain_of_thought_id from callback_metadata (could be dict or object)
+        if isinstance(callback_metadata, dict):
+            chain_of_thought_id = callback_metadata.get("chain_of_thought_id")
+        else:
+            chain_of_thought_id = getattr(callback_metadata, "chain_of_thought_id", None)
+
+        if not chain_of_thought_id:
+            return values
+
+        # Parse data if it's a JSON string
+        if isinstance(data, str):
+            try:
+                data = json.loads(data)
+                values["data"] = data
+            except (json.JSONDecodeError, TypeError):
+                return values
+
+        # If data is a dict, set the id in chain_of_thought
+        if isinstance(data, dict):
+            chain_of_thought = data.get("chain_of_thought")
+            if isinstance(chain_of_thought, dict):
+                chain_of_thought["id"] = chain_of_thought_id
+
+        return values
+
+
+
+# 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_output: ExpectedOutputSmartFollowUp
+    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)
@@ -202,7 +292,7 @@ class GetChatWithPromptForFollowUpEventData(BaseModel):
     """Data for get chat with prompt for follow-up event"""
     chat_id: StrObjectId
     company_id: StrObjectId
-    smart_follow_up_id: StrObjectId
+    smart_follow_up_id: Optional[StrObjectId] = Field(default=None, description="Smart follow-up ID")
     # Trigger information
     trigger: ChainOfThoughtInChatTrigger
     # trigger_id is derived from: smart_follow_up_id
@@ -322,7 +412,8 @@ class EscalateAIAgentInChatEventData(BaseModel):
     """Data for escalating an AI agent (requiring human intervention)"""
     chat_id: StrObjectId
     company_id: StrObjectId
-    reason: str = Field(description="Reason for escalation (e.g., 'Complex technical issue', 'Customer request')")
+    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")
 
 
 class EscalateAIAgentInChatEvent(LambdaAiEvent):
@@ -354,6 +445,24 @@ class UnescalateAIAgentInChatEvent(LambdaAiEvent):
     data: UnescalateAIAgentInChatEventData
 
 
+
+class GetChainOfThoughtsByChatIdEventData(BaseModel):
+    """Data for getting chain of thoughts by chat ID"""
+    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")
+
+
+class GetChainOfThoughtsByChatIdEvent(LambdaAiEvent):
+    """
+    Event to get chain of thoughts for a chat.
+
+    Returns a list of chain of thoughts associated with the given chat ID,
+    sorted by created_at (newest first), with pagination support via skip.
+    """
+    type: InvokationType = InvokationType.GET_CHAIN_OF_THOUGHTS_BY_CHAT_ID
+    data: GetChainOfThoughtsByChatIdEventData
 # Launch Events
 
 class LaunchCommunicationEventData(BaseModel):

{letschatty-0.4.341 → letschatty-0.4.342}/src/letschatty/models/ai_microservices/lambda_invokation_types.py

@@ -11,13 +11,14 @@ class InvokationType(StrEnum):
     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"
@@ -30,6 +31,7 @@ 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"

{letschatty-0.4.341 → letschatty-0.4.342}/src/letschatty/models/ai_microservices/n8n_ai_agents_payload.py

@@ -1,3 +1,4 @@
+from letschatty.models.company.assets.chat_assets import ChainOfThoughtInChatTrigger
 from pydantic import BaseModel, Field
 from letschatty.models import StrObjectId
 from letschatty.models.company.assets.ai_agents_v2.chatty_ai_agent import N8NWorkspaceAgentType
@@ -10,4 +11,5 @@ class SmartFollowUpN8NPayload(BaseModel):
 class ManualTriggerN8NPayload(BaseModel):
     chat_id: StrObjectId = Field(description="The id of the chat")
     company_id: StrObjectId = Field(description="The id of the company")
-    n8n_agent_type: N8NWorkspaceAgentType = Field(description="The type of agent to redirect the message to")
+    n8n_agent_type: N8NWorkspaceAgentType = Field(description="The type of agent to redirect the message to")
+    trigger: ChainOfThoughtInChatTrigger = Field(default=ChainOfThoughtInChatTrigger.MANUAL_TRIGGER)

{letschatty-0.4.341 → letschatty-0.4.342}/src/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 ChatFunnel, StageTransition, ActiveFunnel
+from ...company.CRM.funnel import ClientFunnel, StageTransition
 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,4 +28,5 @@ 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_chat import ChattyAIChatEvent, ChattyAIChatData
+from .chat_based_events.ai_agent_execution_event import AIAgentExecutionEvent, AIAgentExecutionEventData

letschatty-0.4.342/src/letschatty/models/analytics/events/chat_based_events/ai_agent_execution_event.py

@@ -0,0 +1,71 @@
+"""AI Agent Execution Events - Track AI agent lifecycle and decision-making"""
+
+from ..base import Event, EventData
+from ..event_types import EventType
+from .chat_based_event import CustomerEventData
+from typing import ClassVar, Optional, Dict, Any
+from ....utils.types.identifier import StrObjectId
+
+
+class AIAgentExecutionEventData(CustomerEventData):
+    """Data for AI agent execution events"""
+    ai_agent_id: StrObjectId
+    chain_of_thought_id: StrObjectId
+    trigger: str  # USER_MESSAGE, FOLLOW_UP, MANUAL_TRIGGER, RETRY
+    decision_type: Optional[str] = None  # send, suggest, escalate, skip
+    error_message: Optional[str] = None
+    duration_ms: Optional[int] = None
+    user_rating: Optional[int] = None  # 1-5 stars
+    metadata: Optional[Dict[str, Any]] = None
+
+
+class AIAgentExecutionEvent(Event):
+    """
+    Events for AI agent execution lifecycle.
+
+    This event type covers the entire AI agent decision-making process,
+    from trigger to final decision, including all intermediate steps.
+    """
+    data: AIAgentExecutionEventData
+
+    VALID_TYPES: ClassVar[set] = {
+        # Trigger events
+        EventType.CHATTY_AI_AGENT_IN_CHAT_TRIGGER_USER_MESSAGE,
+        EventType.CHATTY_AI_AGENT_IN_CHAT_TRIGGER_FOLLOW_UP,
+        EventType.CHATTY_AI_AGENT_IN_CHAT_TRIGGER_MANUAL,
+        EventType.CHATTY_AI_AGENT_IN_CHAT_TRIGGER_RETRY,
+
+        # State events
+        EventType.CHATTY_AI_AGENT_IN_CHAT_STATE_PROCESSING_STARTED,
+        EventType.CHATTY_AI_AGENT_IN_CHAT_STATE_CALL_STARTED,
+        EventType.CHATTY_AI_AGENT_IN_CHAT_STATE_ESCALATED,
+        EventType.CHATTY_AI_AGENT_IN_CHAT_STATE_UNESCALATED,
+
+        # Call events
+        EventType.CHATTY_AI_AGENT_IN_CHAT_CALL_GET_CHAT_WITH_PROMPT,
+        EventType.CHATTY_AI_AGENT_IN_CHAT_CALL_TAGGER,
+        EventType.CHATTY_AI_AGENT_IN_CHAT_CALL_DOUBLE_CHECKER,
+        EventType.CHATTY_AI_AGENT_IN_CHAT_CALL_DEBUGGER,
+
+        # Callback events
+        EventType.CHATTY_AI_AGENT_IN_CHAT_CALLBACK_GET_CHAT_WITH_PROMPT,
+        EventType.CHATTY_AI_AGENT_IN_CHAT_CALLBACK_TAGGER,
+        EventType.CHATTY_AI_AGENT_IN_CHAT_CALLBACK_DOUBLE_CHECKER,
+        EventType.CHATTY_AI_AGENT_IN_CHAT_CALLBACK_OUTPUT_RECEIVED,
+
+        # Decision events
+        EventType.CHATTY_AI_AGENT_IN_CHAT_DECISION_SEND,
+        EventType.CHATTY_AI_AGENT_IN_CHAT_DECISION_SUGGEST,
+        EventType.CHATTY_AI_AGENT_IN_CHAT_DECISION_ESCALATE,
+        EventType.CHATTY_AI_AGENT_IN_CHAT_DECISION_SKIP,
+        EventType.CHATTY_AI_AGENT_IN_CHAT_DECISION_SENT_TO_API,
+        EventType.CHATTY_AI_AGENT_IN_CHAT_DECISION_COMPLETED,
+
+        # Error events
+        EventType.CHATTY_AI_AGENT_IN_CHAT_ERROR_CALL_FAILED,
+        EventType.CHATTY_AI_AGENT_IN_CHAT_ERROR_CALL_CANCELLED,
+        EventType.CHATTY_AI_AGENT_IN_CHAT_ERROR_VALIDATION_FAILED,
+
+        # Rating events
+        EventType.CHATTY_AI_AGENT_IN_CHAT_RATING_RECEIVED,
+    }

letschatty-0.4.342/src/letschatty/models/analytics/events/chat_based_events/chat_funnel.py

@@ -0,0 +1,40 @@
+from typing import ClassVar, Optional
+from pydantic import Field, field_validator, ValidationInfo
+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
+import json
+
+class FunnelEventData(CustomerEventData):
+    funnel_id: StrObjectId
+    funnel_stage_transition: StageTransition
+    time_in_funnel_seconds: Optional[int] = None
+
+class ChatFunnelEvent(Event):
+    """Event for tracking chat funnel stage transitions"""
+    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_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")
+        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

{letschatty-0.4.341 → letschatty-0.4.342}/src/letschatty/models/analytics/events/company_based_events/asset_events.py

@@ -58,9 +58,6 @@ 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,
@@ -73,9 +70,6 @@ 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
@@ -83,9 +77,8 @@ class AssetEvent(Event):
 
     @model_validator(mode='after')
     def validate_data_fields(self):
-        # 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")
+        if "deleted" not in self.type.value and not self.data.asset:
+            raise ValueError("asset must be set for all events except DELETED")
         return self
 
     def model_dump_json(self, *args, **kwargs):

{letschatty-0.4.341 → letschatty-0.4.342}/src/letschatty/models/analytics/events/event_type_to_classes.py

@@ -41,9 +41,10 @@ EVENT_TO_TYPE_CLASSES = {
     #CONTINUOUS CONVERSATION
     EventType.CONTINUOUS_CONVERSATION_CREATED : ContinuousConversationEvent,
     EventType.CONTINUOUS_CONVERSATION_UPDATED : ContinuousConversationEvent,
-    #CHAT FUNNEL EVENTS
+    #FUNNEL STAGES
+    # Funnel-level events
     EventType.CHAT_FUNNEL_STARTED : ChatFunnelEvent,
-    EventType.CHAT_FUNNEL_STAGE_CHANGED : ChatFunnelEvent,
+    EventType.CHAT_FUNNEL_UPDATED : ChatFunnelEvent,
     EventType.CHAT_FUNNEL_COMPLETED : ChatFunnelEvent,
     EventType.CHAT_FUNNEL_ABANDONED : ChatFunnelEvent,
 
@@ -85,10 +86,6 @@ 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-0.4.341 → letschatty-0.4.342}/src/letschatty/models/analytics/events/event_types.py

@@ -12,6 +12,51 @@ 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"
@@ -42,9 +87,10 @@ class EventType(StrEnum):
     #CONTINUOUS CONVERSATION
     CONTINUOUS_CONVERSATION_CREATED = "chat.continuous_conversation.created"
     CONTINUOUS_CONVERSATION_UPDATED = "chat.continuous_conversation.updated"
-    #CHAT FUNNEL EVENTS
-    CHAT_FUNNEL_STARTED = "chat.funnel.started"
-    CHAT_FUNNEL_STAGE_CHANGED = "chat.funnel.stage_changed"
+    #FUNNEL STAGES
+    # Funnel-level events
+    CHAT_FUNNEL_STARTED = "chat.funnel.started"  # New
+    CHAT_FUNNEL_UPDATED = "chat.funnel.updated"
     CHAT_FUNNEL_COMPLETED = "chat.funnel.completed"
     CHAT_FUNNEL_ABANDONED = "chat.funnel.abandoned"
 
@@ -83,18 +129,13 @@ class EventType(StrEnum):
     FAST_ANSWER_CREATED = "company.fast_answer.created"
     FAST_ANSWER_UPDATED = "company.fast_answer.updated"
     FAST_ANSWER_DELETED = "company.fast_answer.deleted"
-    #FUNNELS
+    #FUNNEL STAGES
     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"

{letschatty-0.4.341 → letschatty-0.4.342}/src/letschatty/models/chat/chat.py

@@ -19,7 +19,6 @@ 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__)
@@ -48,7 +47,6 @@ 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
@@ -269,17 +267,7 @@ class Chat(CompanyAssetModel):
     @property
     def bought_product_ids(self) -> List[StrObjectId]:
         """Get all sale ids in the chat"""
-        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
+        return [sale.product_id for sale in self.sales]
 
     @property
     def products(self) -> List[AssignedAssetToChat]:
@@ -376,3 +364,4 @@ 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
+