letschatty 0.4.349__py3-none-any.whl → 0.4.351__py3-none-any.whl

letschatty/services/events/events_manager.py

@@ -1,2 +1,219 @@
-from letschatty.models.base_models.singleton import SingletonMeta
+"""
+Events Manager - Handles queuing and publishing events to EventBridge
 
+This is a generic implementation that can be configured for different environments.
+"""
+from ...models.base_models.singleton import SingletonMeta
+from ...models.analytics.events.base import Event, EventType
+from typing import List, Optional, Callable
+import logging
+import boto3
+import queue
+import threading
+import time
+from datetime import datetime
+from zoneinfo import ZoneInfo
+import os
+import json
+
+logger = logging.getLogger("EventsManager")
+
+
+class EventsManager(metaclass=SingletonMeta):
+    """
+    Manages event queuing and publishing to AWS EventBridge.
+
+    Can be configured via environment variables or init parameters.
+    """
+
+    def __init__(self,
+                 event_bus_name: Optional[str] = None,
+                 source: Optional[str] = None,
+                 publish_events: Optional[bool] = None,
+                 failed_events_callback: Optional[Callable] = None):
+        """
+        Initialize EventsManager.
+
+        Args:
+            event_bus_name: AWS EventBridge event bus name (or uses env var)
+            source: Source identifier for events (or uses env var)
+            publish_events: Whether to publish events (or uses env var)
+            failed_events_callback: Optional callback for handling failed events
+        """
+        self.events_queue: queue.Queue[Event] = queue.Queue()
+        self.eventbridge_client = boto3.client('events', region_name='us-east-1')
+
+        # Configuration - prefer parameters, fall back to env vars
+        self.event_bus_name = event_bus_name or os.getenv('CHATTY_EVENT_BUS_NAME', 'chatty-events')
+        self.source = source or os.getenv('CHATTY_EVENT_SOURCE')
+        if not self.source:
+            raise ValueError("Source must be provided either as a parameter or through the CHATTY_EVENT_SOURCE environment variable.")
+        self.publish_events = publish_events if publish_events is not None else os.getenv('PUBLISH_EVENTS_TO_EVENTBRIDGE', 'true').lower() == 'true'
+
+        self.max_retries = 3
+        self.thread_lock = threading.Lock()
+        self.thread_running = False
+        self.max_thread_runtime = 300
+        self.failed_events_callback = failed_events_callback
+
+        logger.debug(f"EventsManager initialized: bus={self.event_bus_name}, source={self.source}, publish={self.publish_events}")
+
+    def queue_events(self, events: List[Event]):
+        """Queue events and spawn a thread to publish them if one isn't already running"""
+        if not self.publish_events:
+            logger.debug("Event publishing disabled, skipping")
+            return
+
+        for event in events:
+            logger.debug(f"Queueing event: {event.type.value} {event.company_id}")
+            logger.debug(f"Event: {event.model_dump_json()}")
+            self.events_queue.put(event)
+
+        logger.debug(f"Queued {len(events)} events")
+        if events:
+            logger.debug(f"1° event: {events[0].model_dump_json()}")
+
+        # Only start a new thread if one isn't already running
+        with self.thread_lock:
+            if not self.thread_running:
+                logger.debug("Starting publisher thread")
+                self.thread_running = True
+                thread = threading.Thread(
+                    target=self._process_queue,
+                    daemon=True,
+                    name="EventBridge-Publisher"
+                )
+                thread.start()
+                logger.debug("Started publisher thread")
+            else:
+                logger.debug("Publisher thread already running, using existing thread")
+
+    def _process_queue(self):
+        """Process all events in the queue and then terminate"""
+        try:
+            start_time = time.time()
+            while not self.events_queue.empty():
+                logger.debug("Processing queue")
+                events_batch = []
+                if time.time() - start_time > self.max_thread_runtime:
+                    logger.warning(f"Thread ran for more than {self.max_thread_runtime}s - terminating")
+                    break
+
+                # Collect up to 10 events (EventBridge limit)
+                for _ in range(10):
+                    try:
+                        event = self.events_queue.get(timeout=0.5)
+                        events_batch.append(event)
+                        self.events_queue.task_done()
+                    except queue.Empty:
+                        logger.debug("Queue is empty")
+                        break
+
+                # Publish this batch
+                if events_batch:
+                    self._publish_batch(events_batch)
+
+        except Exception as e:
+            logger.exception(f"Error in publisher thread: {str(e)}")
+
+        finally:
+            # Mark thread as completed
+            with self.thread_lock:
+                self.thread_running = False
+
+    def _publish_batch(self, events: List[Event]):
+        """Send a batch of events to EventBridge with retries"""
+        if not events:
+            return
+
+        entries = []
+        for event in events:
+            entry = {
+                'Source': self.source,
+                'DetailType': event.type.value,
+                'Detail': json.dumps(event.model_dump_json()),
+                'EventBusName': self.event_bus_name
+            }
+            logger.debug(f"Appending event: {event.type.value}")
+            entries.append(entry)
+
+        for retry in range(self.max_retries):
+            try:
+                logger.debug(f"Sending {len(entries)} events to EventBridge")
+                logger.debug(f"Entries: {entries}")
+                response = self.eventbridge_client.put_events(Entries=entries)
+                logger.debug(f"Response: {response}")
+
+                if response.get('FailedEntryCount', 0) == 0:
+                    logger.info(f"Successfully published {len(events)} events")
+                    return
+
+                # Handle partial failures
+                failed_entries: List[dict] = []
+                failed_events: List[Event] = []
+
+                for i, result in enumerate(response.get('Entries', [])):
+                    if 'ErrorCode' in result:
+                        failed_entries.append(entries[i])
+                        failed_events.append(events[i])
+                        logger.error(f"Failed to publish event: {events[i].type.value}")
+
+                if retry < self.max_retries - 1 and failed_entries:
+                    logger.info(f"Retrying {len(failed_entries)} events")
+                    entries = failed_entries
+                    events = failed_events
+                else:
+                    # Store failed events via callback if provided
+                    if self.failed_events_callback and failed_events:
+                        failed_events_with_errors = []
+                        for i, event in enumerate(failed_events):
+                            result = response.get('Entries', [])[i]
+                            failed_event_data = {
+                                "event": event.model_dump_json(),
+                                "error_code": result.get('ErrorCode'),
+                                "error_message": result.get('ErrorMessage'),
+                                "retry_count": self.max_retries,
+                                "timestamp": datetime.now(ZoneInfo("UTC"))
+                            }
+                            failed_events_with_errors.append(failed_event_data)
+
+                        try:
+                            self.failed_events_callback(failed_events_with_errors)
+                        except Exception as e:
+                            logger.error(f"Error calling failed_events_callback: {e}")
+
+                    logger.error(f"Gave up on {len(failed_entries)} events after {self.max_retries} attempts")
+                    return
+
+            except Exception as e:
+                if retry < self.max_retries - 1:
+                    logger.warning(f"Error publishing events (attempt {retry+1}/{self.max_retries}): {str(e)}")
+                    time.sleep(0.5 * (2 ** retry))  # Exponential backoff
+                else:
+                    logger.exception(f"Failed to publish events after {self.max_retries} attempts")
+                    return
+
+    def flush(self):
+        """Wait for all queued events to be processed"""
+        # If no thread is running but we have events, start one
+        with self.thread_lock:
+            if not self.thread_running and not self.events_queue.empty():
+                self.thread_running = True
+                thread = threading.Thread(
+                    target=self._process_queue,
+                    daemon=True,
+                    name="EventBridge-Publisher"
+                )
+                thread.start()
+
+        # Wait for queue to be empty
+        try:
+            self.events_queue.join()
+            return True
+        except Exception:
+            logger.warning("Error waiting for events queue to complete")
+            return False
+
+
+# Singleton instance
+events_manager = EventsManager()

letschatty/services/factories/analytics/ai_agent_event_factory.py

@@ -0,0 +1,161 @@
+"""
+AI Agent Event Factory - Helper for creating AI agent execution events
+
+This factory simplifies event creation by providing a consistent interface
+for generating both full analytics events and simplified UI events.
+"""
+
+from letschatty.models.analytics.events.chat_based_events.ai_agent_execution_event import (
+    AIAgentExecutionEvent,
+    AIAgentExecutionEventData
+)
+from letschatty.models.analytics.events.event_types import EventType
+from datetime import datetime
+from zoneinfo import ZoneInfo
+from typing import Optional, Dict, Any
+from letschatty.models.utils.types.identifier import StrObjectId
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class AIAgentEventFactory:
+    """
+    Factory for creating AI agent execution events with proper context.
+
+    Provides a simplified API for event creation while ensuring all required
+    fields are properly populated for analytics and monitoring.
+    """
+
+    @staticmethod
+    def create_event(
+        event_type: EventType,
+        chat_id: StrObjectId,
+        company_id: StrObjectId,
+        frozen_company_name: str,
+        ai_agent_id: StrObjectId,
+        chain_of_thought_id: StrObjectId,
+        trigger: str,
+        source: str = "chatty.api",
+        decision_type: Optional[str] = None,
+        error_message: Optional[str] = None,
+        duration_ms: Optional[int] = None,
+        user_rating: Optional[int] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        trace_id: Optional[str] = None
+    ) -> AIAgentExecutionEvent:
+        """
+        Create a full AI agent execution event for EventBridge.
+
+        Args:
+            event_type: The type of event (from EventType enum)
+            chat_id: ID of the chat where the event occurred
+            company_id: ID of the company
+            frozen_company_name: Company name snapshot for analytics
+            ai_agent_id: ID of the AI agent asset
+            chain_of_thought_id: ID of the chain of thought execution
+            trigger: What triggered the execution (USER_MESSAGE, FOLLOW_UP, etc.)
+            source: Event source (e.g., 'chatty.api', 'chatty.lambda')
+            decision_type: Type of decision if applicable (send, suggest, escalate, skip)
+            error_message: Error message if this is an error event
+            duration_ms: Duration of the operation in milliseconds
+            user_rating: User rating (1-5 stars) if applicable
+            metadata: Additional event-specific data
+            trace_id: Trace ID for tracking event flows across systems
+
+        Returns:
+            AIAgentExecutionEvent ready to be queued to EventBridge
+        """
+        return AIAgentExecutionEvent(
+            type=event_type,
+            time=datetime.now(ZoneInfo("UTC")),
+            source=source,
+            company_id=company_id,
+            frozen_company_name=frozen_company_name,
+            specversion="1.0",
+            trace_id=trace_id,
+            data=AIAgentExecutionEventData(
+                chat_id=chat_id,
+                ai_agent_id=ai_agent_id,
+                chain_of_thought_id=chain_of_thought_id,
+                trigger=trigger,
+                decision_type=decision_type,
+                error_message=error_message,
+                duration_ms=duration_ms,
+                user_rating=user_rating,
+                metadata=metadata
+            )
+        )
+
+    @staticmethod
+    def get_simplified_event_type(event_type: EventType) -> str:
+        """
+        Convert full EventType to simplified event type string for UI.
+
+        Transforms 'chatty_ai_agent_in_chat.trigger.user_message' -> 'trigger.user_message'
+        This provides a cleaner format for embedded events in COT documents.
+
+        Args:
+            event_type: Full EventType enum value
+
+        Returns:
+            Simplified event type string (e.g., 'trigger.user_message')
+        """
+        # Extract the last two parts after 'chatty_ai_agent_in_chat.'
+        parts = event_type.value.split('.')
+        if len(parts) >= 3 and parts[0] == 'chatty_ai_agent_in_chat':
+            return '.'.join(parts[1:])  # e.g., 'trigger.user_message'
+        return event_type.value  # Fallback to full type if format doesn't match
+
+    @staticmethod
+    def get_user_friendly_message(event_type: EventType, **context) -> str:
+        """
+        Generate a user-friendly message for an event type.
+
+        This provides human-readable descriptions for events that will be
+        displayed in the UI as part of the chain of thought timeline.
+
+        Args:
+            event_type: The type of event
+            **context: Additional context for message formatting (e.g., decision_type, error_message)
+
+        Returns:
+            User-friendly message string
+        """
+        messages = {
+            EventType.CHATTY_AI_AGENT_IN_CHAT_TRIGGER_USER_MESSAGE: "Triggered by user message",
+            EventType.CHATTY_AI_AGENT_IN_CHAT_TRIGGER_FOLLOW_UP: "Triggered by smart follow-up",
+            EventType.CHATTY_AI_AGENT_IN_CHAT_TRIGGER_MANUAL: "Manually triggered",
+            EventType.CHATTY_AI_AGENT_IN_CHAT_TRIGGER_RETRY: "Retry triggered",
+
+            EventType.CHATTY_AI_AGENT_IN_CHAT_STATE_PROCESSING_STARTED: "Processing started",
+            EventType.CHATTY_AI_AGENT_IN_CHAT_STATE_CALL_STARTED: "AI agent call started",
+            EventType.CHATTY_AI_AGENT_IN_CHAT_STATE_ESCALATED: "Escalated to human agent",
+            EventType.CHATTY_AI_AGENT_IN_CHAT_STATE_UNESCALATED: "Returned to AI agent",
+
+            EventType.CHATTY_AI_AGENT_IN_CHAT_CALL_GET_CHAT_WITH_PROMPT: "Requesting chat context",
+            EventType.CHATTY_AI_AGENT_IN_CHAT_CALL_TAGGER: "Calling tagger service",
+            EventType.CHATTY_AI_AGENT_IN_CHAT_CALL_DOUBLE_CHECKER: "Calling double checker",
+            EventType.CHATTY_AI_AGENT_IN_CHAT_CALL_DEBUGGER: "Running debugger",
+
+            EventType.CHATTY_AI_AGENT_IN_CHAT_CALLBACK_GET_CHAT_WITH_PROMPT: "Chat context received",
+            EventType.CHATTY_AI_AGENT_IN_CHAT_CALLBACK_TAGGER: "Tagger response received",
+            EventType.CHATTY_AI_AGENT_IN_CHAT_CALLBACK_DOUBLE_CHECKER: "Double checker validation complete",
+            EventType.CHATTY_AI_AGENT_IN_CHAT_CALLBACK_OUTPUT_RECEIVED: "AI agent output received",
+
+            EventType.CHATTY_AI_AGENT_IN_CHAT_DECISION_SEND: "Decision: Send message",
+            EventType.CHATTY_AI_AGENT_IN_CHAT_DECISION_SUGGEST: "Decision: Suggest message",
+            EventType.CHATTY_AI_AGENT_IN_CHAT_DECISION_ESCALATE: "Decision: Escalate to human",
+            EventType.CHATTY_AI_AGENT_IN_CHAT_DECISION_SKIP: "Decision: Skip message",
+            EventType.CHATTY_AI_AGENT_IN_CHAT_DECISION_SENT_TO_API: "Decision sent to API",
+            EventType.CHATTY_AI_AGENT_IN_CHAT_DECISION_COMPLETED: "Decision completed successfully",
+
+            EventType.CHATTY_AI_AGENT_IN_CHAT_ERROR_CALL_FAILED: f"Call failed: {context.get('error_message', 'Unknown error')}",
+            EventType.CHATTY_AI_AGENT_IN_CHAT_ERROR_CALL_CANCELLED: "Call cancelled",
+            EventType.CHATTY_AI_AGENT_IN_CHAT_ERROR_VALIDATION_FAILED: f"Validation failed: {context.get('error_message', 'Invalid data')}",
+
+            EventType.CHATTY_AI_AGENT_IN_CHAT_RATING_RECEIVED: f"User rated: {context.get('user_rating', '?')}/5 stars",
+        }
+
+        return messages.get(event_type, str(event_type))
+

letschatty/services/factories/analytics/events_factory.py

@@ -1,6 +1,7 @@
 from typing import Optional, Dict, Any
 from datetime import datetime
 from ....models.analytics.events import *
+from ....models.analytics.events.chat_based_events.ai_agent_execution_event import AIAgentExecutionEvent
 from ....models.base_models.chatty_asset_model import ChattyAssetModel
 from ....models.company.assets.chat_assets import AssignedAssetToChat
 from ....models.company.empresa import EmpresaModel
@@ -321,7 +322,7 @@ class EventFactory:
         return events
 
     @staticmethod
-    def funnel_stage_events(chat_with_assets: ChatWithAssets, company_info: EmpresaModel, trace_id: str,executor_type: ExecutorType, executor_id: StrObjectId, chat_funnel: ChatFunnel, funnel_transition: StageTransition, event_type: EventType, time: datetime, company_snapshot: Optional[CompanyChatsSnapshot] = None, agent_snapshot: Optional[AgentChatsSnapshot] = None) -> List[Event]:
+    def funnel_stage_events(chat_with_assets: ChatWithAssets, company_info: EmpresaModel, trace_id: str,executor_type: ExecutorType, executor_id: StrObjectId, chat_funnel: ClientFunnel, funnel_transition: StageTransition, event_type: EventType, time: datetime, company_snapshot: Optional[CompanyChatsSnapshot] = None, agent_snapshot: Optional[AgentChatsSnapshot] = None) -> List[Event]:
         events = []
         base_data = EventFactory._create_base_customer_event_data(
                                                                     chat_with_assets=chat_with_assets,
@@ -334,10 +335,8 @@ class EventFactory:
         funnel_data = FunnelEventData(
             **base_data.model_dump(),
             funnel_id=chat_funnel.funnel_id,
-            chat_funnel_id=chat_funnel.id,
-            stage_transition=funnel_transition,
-            time_in_funnel_seconds=chat_funnel.time_in_funnel_seconds,
-            time_in_last_stage_seconds=chat_funnel.time_in_current_stage_seconds
+            funnel_stage_transition=funnel_transition,
+            time_in_funnel_seconds=chat_funnel.time_in_funnel_seconds
         )
         event = ChatFunnelEvent(
             specversion=EventFactory.package_version(),
@@ -415,30 +414,6 @@ class EventFactory:
         events.append(event)
         return events
 
-    @staticmethod
-    def chat_client_updated_events(chat_with_assets: ChatWithAssets, company_info: EmpresaModel, trace_id: str, executor_type: ExecutorType, executor_id: StrObjectId, event_type: EventType, time: datetime, company_snapshot: Optional[CompanyChatsSnapshot] = None, agent_snapshot: Optional[AgentChatsSnapshot] = None) -> List[Event]:
-        events = []
-        base_data = EventFactory._create_base_customer_event_data(
-            chat_with_assets=chat_with_assets,
-            company_info=company_info,
-            executor_type=executor_type,
-            executor_id=executor_id,
-            company_snapshot=company_snapshot,
-            agent_snapshot=agent_snapshot
-        )
-        event = ChatClientEvent(
-            specversion=EventFactory.package_version(),
-            type=event_type,
-            time=time,
-            data=base_data,
-            source="chatty_api.webapp",
-            company_id=company_info.id,
-            frozen_company_name=company_info.frozen_name,
-            trace_id=trace_id
-        )
-        events.append(event)
-        return events
-
     @staticmethod
     def chat_created_events(chat_with_assets: ChatWithAssets, company_info: EmpresaModel, trace_id: str,executor_type: ExecutorType, executor_id: StrObjectId, event_type: EventType, time: datetime, contact_point_id: Optional[StrObjectId], created_from: ChatCreatedFrom, company_snapshot: Optional[CompanyChatsSnapshot] = None, agent_snapshot: Optional[AgentChatsSnapshot] = None) -> List[Event]:
         events = []
@@ -637,4 +612,65 @@ class EventFactory:
             trace_id=trace_id
         )
         events.append(event)
-        return events
+        return events
+
+    @staticmethod
+    def ai_agent_execution_event(
+        event_type: EventType,
+        chat_id: StrObjectId,
+        company_id: StrObjectId,
+        frozen_company_name: str,
+        ai_agent_id: StrObjectId,
+        chain_of_thought_id: StrObjectId,
+        trigger: str,
+        source: str = "chatty.api",
+        decision_type: Optional[str] = None,
+        error_message: Optional[str] = None,
+        duration_ms: Optional[int] = None,
+        user_rating: Optional[int] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        trace_id: Optional[str] = None
+    ) -> AIAgentExecutionEvent:
+        """
+        Create an AI agent execution event using the modularized AIAgentEventFactory.
+
+        This method delegates to AIAgentEventFactory to maintain modularity while
+        keeping event creation centralized through EventsFactory.
+
+        Args:
+            event_type: The type of event (from EventType enum)
+            chat_id: ID of the chat where the event occurred
+            company_id: ID of the company
+            frozen_company_name: Company name snapshot for analytics
+            ai_agent_id: ID of the AI agent asset
+            chain_of_thought_id: ID of the chain of thought execution
+            trigger: What triggered the execution (USER_MESSAGE, FOLLOW_UP, etc.)
+            source: Event source (e.g., 'chatty.api', 'chatty.lambda')
+            decision_type: Type of decision if applicable
+            error_message: Error message if this is an error event
+            duration_ms: Duration of the operation in milliseconds
+            user_rating: User rating (1-5 stars) if applicable
+            metadata: Additional event-specific data
+            trace_id: Trace ID for tracking event flows
+
+        Returns:
+            AIAgentExecutionEvent ready to be queued to EventBridge
+        """
+        from .ai_agent_event_factory import AIAgentEventFactory
+
+        return AIAgentEventFactory.create_event(
+            event_type=event_type,
+            chat_id=chat_id,
+            company_id=company_id,
+            frozen_company_name=frozen_company_name,
+            ai_agent_id=ai_agent_id,
+            chain_of_thought_id=chain_of_thought_id,
+            trigger=trigger,
+            source=source,
+            decision_type=decision_type,
+            error_message=error_message,
+            duration_ms=duration_ms,
+            user_rating=user_rating,
+            metadata=metadata,
+            trace_id=trace_id
+        )

letschatty/services/factories/lambda_ai_orchestrartor/lambda_events_factory.py

@@ -1,8 +1,27 @@
 
 from letschatty.models import StrObjectId
-from letschatty.models.ai_microservices.lambda_events import DoubleCheckerForIncomingMessagesAnswerCallbackEvent, DoubleCheckerForIncomingMessagesAnswerEvent, FixBuggedAiAgentsCallsInChatsEvent, QualityTestEventData, QualityTestsForUpdatedAIComponentEvent, QualityTestsForUpdatedAIComponentEventData
+from letschatty.models.ai_microservices.lambda_events import (
+    DoubleCheckerForIncomingMessagesAnswerCallbackEvent,
+    DoubleCheckerForIncomingMessagesAnswerEvent,
+    FixBuggedAiAgentsCallsInChatsEvent,
+    GetChainOfThoughtsByChatIdEvent,
+    QualityTestEventData,
+    QualityTestsForUpdatedAIComponentEvent,
+    QualityTestsForUpdatedAIComponentEventData,
+    CancelExecutionEvent,
+    ManualTriggerEvent,
+    AssignAIAgentToChatEvent,
+    RemoveAIAgentFromChatEvent,
+    SmartFollowUpDecisionOutputEvent,
+    UpdateAIAgentModeInChatEvent,
+    EscalateAIAgentInChatEvent,
+    UnescalateAIAgentInChatEvent,
+    GetChatWithPromptForIncomingMessageEvent,
+    GetChatWithPromptForFollowUpEvent,
+    UpdateAIAgentPrequalStatusInChatEvent,
+)
 from letschatty.models.ai_microservices.lambda_invokation_types import InvokationType
-from letschatty.models.ai_microservices import AllQualityTestEvent, AllQualityTestEventData, FollowUpEvent, IncomingMessageEvent, QualityTestEvent, QualityTestInteractionCallbackEvent, SmartTaggingCallbackEvent, IncomingMessageCallbackEvent, QualityTestCallbackEvent, LambdaAiEvent, SmartTaggingEvent, SmartTaggingPromptEvent
+from letschatty.models.ai_microservices import AllQualityTestEvent, AllQualityTestEventData, QualityTestEvent, QualityTestInteractionCallbackEvent, SmartTaggingCallbackEvent, QualityTestCallbackEvent, LambdaAiEvent, SmartTaggingEvent, SmartTaggingPromptEvent
 from letschatty.models.base_models.ai_agent_component import AiAgentComponent
 from letschatty.models.company.assets.ai_agents_v2.chat_example import ChatExample
 from letschatty.models.company.assets.ai_agents_v2.chat_example_test import ChatExampleTestCase
@@ -19,16 +38,10 @@ class LambdaEventFactory:
                 return SmartTaggingEvent(**event_data)
             case InvokationType.SMART_TAGGING_CALLBACK:
                 return SmartTaggingCallbackEvent(**event_data)
-            case InvokationType.INCOMING_MESSAGE:
-                return IncomingMessageEvent(**event_data)
             case InvokationType.SINGLE_QUALITY_TEST:
                 return QualityTestEvent(**event_data)
             case InvokationType.ALL_QUALITY_TEST:
                 return AllQualityTestEvent(**event_data)
-            case InvokationType.INCOMING_MESSAGE_CALLBACK:
-                return IncomingMessageCallbackEvent(**event_data)
-            case InvokationType.FOLLOW_UP:
-                return FollowUpEvent(**event_data)
             case InvokationType.SINGLE_QUALITY_TEST_CALLBACK:
                 return QualityTestCallbackEvent(**event_data)
             case InvokationType.SMART_TAGGING_PROMPT:
@@ -41,6 +54,31 @@ class LambdaEventFactory:
                 return DoubleCheckerForIncomingMessagesAnswerEvent(**event_data)
             case InvokationType.DOUBLE_CHECKER_FOR_INCOMING_MESSAGES_ANSWER_CALLBACK:
                 return DoubleCheckerForIncomingMessagesAnswerCallbackEvent(**event_data)
+            case InvokationType.MANUAL_TRIGGER:
+                return ManualTriggerEvent(**event_data)
+            case InvokationType.CANCEL_EXECUTION:
+                return CancelExecutionEvent(**event_data)
+            case InvokationType.ASSIGN_AI_AGENT_TO_CHAT:
+                return AssignAIAgentToChatEvent(**event_data)
+            case InvokationType.REMOVE_AI_AGENT_FROM_CHAT:
+                return RemoveAIAgentFromChatEvent(**event_data)
+            case InvokationType.UPDATE_AI_AGENT_MODE_IN_CHAT:
+                return UpdateAIAgentModeInChatEvent(**event_data)
+            case InvokationType.UPDATE_AI_AGENT_PREQUAL_STATUS_IN_CHAT:
+                return UpdateAIAgentPrequalStatusInChatEvent(**event_data)
+            case InvokationType.ESCALATE_AI_AGENT_IN_CHAT:
+                return EscalateAIAgentInChatEvent(**event_data)
+            case InvokationType.UNESCALATE_AI_AGENT_IN_CHAT:
+                return UnescalateAIAgentInChatEvent(**event_data)
+            case InvokationType.GET_CHAIN_OF_THOUGHTS_BY_CHAT_ID:
+                return GetChainOfThoughtsByChatIdEvent(**event_data)
+            case InvokationType.SMART_FOLLOW_UP_DECISION_OUTPUT:
+                return SmartFollowUpDecisionOutputEvent(**event_data)
+
+            case InvokationType.GET_CHAT_WITH_PROMPT_INCOMING_MESSAGE:
+                return GetChatWithPromptForIncomingMessageEvent(**event_data)
+            case InvokationType.GET_CHAT_WITH_PROMPT_FOLLOW_UP:
+                return GetChatWithPromptForFollowUpEvent(**event_data)
             case _:
                 raise ValueError(f"Invalid event type: {event_type}")
 

letschatty/services/messages_helpers/get_caption_or_body_or_preview.py

@@ -1,3 +1,4 @@
+from letschatty.models.messages.chatty_messages.button import ChattyContentButton
 from ...models.messages.chatty_messages.schema import ChattyContent, ChattyContentText, ChattyContentContacts, ChattyContentLocation, ChattyContentImage, ChattyContentVideo, ChattyContentAudio, ChattyContentDocument, ChattyContentSticker, ChattyContentReaction
 class MessageTextOrCaptionOrPreview:
     @staticmethod
@@ -5,9 +6,9 @@ class MessageTextOrCaptionOrPreview:
         if isinstance(message_content, ChattyContentText):
             return message_content.body
         elif isinstance(message_content, ChattyContentContacts):
-            return "👥 Mensaje de tipo contacto"
-        elif isinstance(message_content, ChattyContentLocation):
-            return "📍 Mensaje de tipo ubicación"
+            return f"👤 *Contacto recibido:* {message_content.contacts[0].full_name} \n📞 *Teléfono:* {message_content.contacts[0].phone_number}"
+        elif    isinstance(message_content, ChattyContentLocation):
+            return f"📍 \nLatitud: {message_content.latitude} \nLongitud: {message_content.longitude}_"
         elif isinstance(message_content, ChattyContentImage):
             return "🖼️ Mensaje de tipo imagen"
         elif isinstance(message_content, ChattyContentVideo):
@@ -22,6 +23,7 @@ class MessageTextOrCaptionOrPreview:
             return "😀 Mensaje de tipo sticker"
         elif isinstance(message_content, ChattyContentReaction):
             return "❤️ Mensaje de tipo reacción"
+        elif isinstance(message_content, ChattyContentButton):
+            return f"{message_content.payload}"
         else:
-
             return "Vista previa del mensaje"

letschatty/services/validators/analytics_validator.py

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

{letschatty-0.4.349.dist-info → letschatty-0.4.351.dist-info}/METADATA

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