letschatty 0.4.332__py3-none-any.whl → 0.4.333__py3-none-any.whl

letschatty/models/ai_microservices/__init__.py

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

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")
@@ -169,6 +170,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 = [
@@ -187,3 +194,31 @@ class ExpectedOutputIncomingMessage(BaseModel):
         return incoming_decision
 
 
+class ExpectedOutputSmartFollowUp(BaseModel):
+    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/models/ai_microservices/lambda_events.py

@@ -1,16 +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, IncomingMessageAIDecision
-from ...models.company.assets.ai_agents_v2.ai_agents_decision_output import IncomingMessageDecisionAction
+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
@@ -22,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
@@ -54,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
@@ -77,6 +110,11 @@ 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
@@ -130,11 +168,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
@@ -142,13 +178,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)
@@ -183,7 +279,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
@@ -303,7 +399,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):
@@ -335,6 +432,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/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/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/models/analytics/events/__init__.py

@@ -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/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/models/analytics/events/company_based_events/asset_events.py

@@ -70,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

letschatty/models/analytics/events/event_type_to_classes.py

@@ -86,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/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"

letschatty/models/chat/continuous_conversation.py

@@ -30,7 +30,7 @@ class ContinuousConversation(ChattyAssetModel):
     template_message_waid: Optional[str] = None
     status: Optional[ContinuousConversationStatus] = Field(default=ContinuousConversationStatus.CREATED)
     active: bool = Field(default=True)
-    expires_at: datetime = Field(default_factory=lambda: datetime.now(ZoneInfo("UTC")) + timedelta(days=10))
+    expires_at: datetime = Field(default=datetime.now(ZoneInfo("UTC")) + timedelta(days=10))
     messages: List[MessageDraft]
     creator_id: StrObjectId
     forced_send: bool = Field(default=False)

letschatty/models/company/assets/ai_agents_v2/ai_agents_decision_output.py

@@ -55,7 +55,7 @@ class SmartFollowUpDecision(BaseModel):
                             SmartFollowUpDecisionAction.POSTPONE_DELTA_TIME]:
             # Postpone actions don't require messages
             if self.messages is not None and len(self.messages) > 0:
-                raise ValueError("Messages are not allowed when action is postpone/postponed")
+                raise ValueError("Messages are not allowed when action is postpone")
         else:
             raise ValueError(f"Invalid action: {self.action}")
 

letschatty/models/company/assets/ai_agents_v2/chatty_ai_agent.py

@@ -110,6 +110,12 @@ class ChattyAIAgent(CompanyAssetModel):
     examples: List[StrObjectId] = Field(default_factory=list, description="Training examples")
     double_checker_enabled: bool = Field(default=False, description="Whether the double checker is enabled")
     double_checker_instructions: Optional[str] = Field(default=None, description="Instructions for the double checker")
+    copilot_confidence_threshold: Optional[int] = Field(
+        default=None,
+        ge=0,
+        le=100,
+        description="Confidence threshold 0-100 para modo COPILOT (fallback a env si no está)"
+    )
 
     # Pre-qualification configuration
     pre_qualify: Optional["PreQualifyConfig"] = Field(
@@ -165,4 +171,4 @@ class ChattyAIAgent(CompanyAssetModel):
 
 # Import and rebuild for forward reference resolution
 from .pre_qualify_config import PreQualifyConfig
-ChattyAIAgent.model_rebuild()
+ChattyAIAgent.model_rebuild()

letschatty/models/company/assets/ai_agents_v2/chatty_ai_agent_in_chat.py

@@ -123,6 +123,10 @@ class ChattyAIAgentInChat(CompanyAssetModel):
         default=None,
         description="If the trigger is a user message, this will be the id of the incoming message"
     )
+    last_reset_message_id: Optional[str] = Field(
+        default=None,
+        description="Last reset control trigger message id handled for this chat"
+    )
 
     # Assignment metadata
     assigned_at: datetime = Field(default_factory=lambda: datetime.now(ZoneInfo("UTC")))
@@ -352,4 +356,3 @@ class ChattyAIAgentInChat(CompanyAssetModel):
         """Cancel data collection"""
         self.data_collection_status = DataCollectionStatus.CANCELLED
         self.updated_at = datetime.now(ZoneInfo("UTC"))
-

letschatty/models/company/assets/ai_agents_v2/chatty_ai_mode.py

@@ -16,7 +16,7 @@ class ChattyAIMode(StrEnum):
         return {
             cls.AUTONOMOUS: "El agente de IA tendrá la autonomía de conversar en tiempo real con el usuario, respetando sus instrucciones y las reglas establecidas.",
             cls.SUGGESTIONS: "El agente de IA sugerirá sólo hará sugerencias de respuestas y seguimientos, pero no enviará mensajes ni interactuará de forma directa con el usuario.",
-            cls.COPILOT: "El agente de IA hará sugerencias de respuestas y seguimientos, y responderá de forma directa únicamente aquellas preguntas especificadas en el contexto del agente, en la sección de preguntas frecuentes (FAQ).",
+            cls.COPILOT: "El agente de IA responderá automáticamente cuando tenga alta confianza y la consulta esté dentro del alcance; si no, sugerirá o escalará para revisión humana.",
             cls.OFF: "El agente de IA estará inactivo. No responderá al usuario ni hará sugerencias."
         }[mode]
 
@@ -26,7 +26,7 @@ class ChattyAIMode(StrEnum):
         mode_description = {
             cls.AUTONOMOUS: "Only answer based on the context and rules provided. Do not improvise or make up information. If you can't handle the question, escalate to a human.",
             cls.SUGGESTIONS: "You're only going to be making suggestions, all your messages will be reviewd by a human and you should add the reasoning to your chain of thought. If the user message is not worth answering, you can use the 'skip' action in your output. If the user message is worth answering, you NEED to use the 'suggest' action in your output. ",
-            cls.COPILOT: "You're in a COPILOT mode, so you'll be making suggestions on general inquires, and answer only questions specified in the FAQ section. So, for answers which you're creating based on the context, you'll be making a suggestions, and need to add the 'suggestion' subtype in each message. When asked about a question included in the FAQ, you're allowed to adapt the answer to the user's question, but you're not allowed to improvise or make up information, and you'll set the 'text' subtype in the messages.",
+            cls.COPILOT: "You're in COPILOT mode. Use your confidence to decide the action: send when the request is within scope and you are confident, suggest when you're unsure or a human touch is needed (complex negotiation, frustration, high-value, or missing info), and escalate if it's required by control triggers. Always include a confidence score (0-100).",
             cls.OFF: ""
         }[mode]
         return intro + "\n\n" + mode_description

letschatty/models/company/assets/ai_agents_v2/get_chat_with_prompt_response.py

@@ -25,6 +25,7 @@ class GetChatWithPromptResponse(BaseModel):
             "messages": self.messages,
             "n8n_agent_type": self.chatty_ai_agent.n8n_workspace_agent_type.value if self.chatty_ai_agent else None,
             "n8n_agent_type_parameters": self.chatty_ai_agent.n8n_workspace_agent_type_parameteres.model_dump() if self.chatty_ai_agent else None,
+            "ai_agent_id": self.chatty_ai_agent.id if self.chatty_ai_agent else None,
             "phone_number": self.chat.client.get_waid() if self.chat else None,
             "chain_of_thought_id": self.chain_of_thought_id,
             "trigger_id": self.trigger_id

letschatty/models/company/assets/ai_agents_v2/pre_qualify_config.py

@@ -5,11 +5,17 @@ Defines the data collection, acceptance criteria, and destination actions
 for qualifying/disqualifying users.
 """
 
+from letschatty.models.company.assets.automation import Automation
 from pydantic import BaseModel, Field
 from typing import Optional, List
 from enum import StrEnum
 from letschatty.models.utils.types.identifier import StrObjectId
 
+class PostToExternalApiConfig(BaseModel):
+    """Placeholder provisorio"""
+    url: str = Field(description="The URL to post to")
+    method: str = Field(description="The HTTP method to use")
+    api_key: str
 
 class PreQualifyDestination(StrEnum):
     """
@@ -19,8 +25,11 @@ class PreQualifyDestination(StrEnum):
     CALENDAR_SCHEDULER = "calendar_scheduler"    # Allow AI agent to schedule meetings
     ESCALATE = "escalate"                        # Escalate to human
     CUSTOM_MESSAGE = "custom_message"            # Send a custom message
+    AUTO_ASSIGN_HUMAN_AGENT = "auto_assign_human_agent" #
     CONTINUE = "continue"                        # Continue normal AI agent flow
-    NONE = "none"                                # Do nothing
+    NONE = "none"                                # Do nothing (no-op)
+    ARCHIVE = "archive"
+    POST_TO_EXTERNAL_API = "post_to_external_api"
 
 
 class PreQualifyFormField(BaseModel):
@@ -68,6 +77,10 @@ class PreQualifyConfig(BaseModel):
         default=None,
         description="Custom message to send when user does NOT qualify (if destination is custom_message or escalate)"
     )
+    post_to_external_api : Optional[PostToExternalApiConfig] = Field(
+        default=None,
+        description="Configuration for posting to an external API"
+    )
 
     @property
     def has_form_fields(self) -> bool:
@@ -108,4 +121,3 @@ class PreQualifyConfig(BaseModel):
         original_len = len(self.form_fields)
         self.form_fields = [f for f in self.form_fields if f.field_key != field_key]
         return len(self.form_fields) < original_len
-