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

letschatty/services/chatty_assets/base_container_with_collection.py

@@ -64,8 +64,7 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
         self.update_previews_thread()
         self.load_from_db_thread(company_id=None)
 
-    # All methods are now async-only for better performance
-    async def insert(self, item: T, execution_context: ExecutionContext) -> T:
+    def insert(self, item: T, execution_context: ExecutionContext) -> T:
         """
         Add an item to the container and insert it into the database collection.
 
@@ -78,12 +77,12 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
         """
         logger.debug(f"{self.__class__.__name__} inserting item {item}")
         inserted_item = super().insert(item)
-        await self.collection.insert(inserted_item)
+        self.collection.insert(inserted_item)
         execution_context.set_event_time(inserted_item.created_at)
         self.update_previews_thread()
         return inserted_item
 
-    async def update(self, id: str, new_item: T, execution_context: ExecutionContext) -> T:
+    def update(self, id: str, new_item: T, execution_context: ExecutionContext) -> T:
         """
         Update an item in the container and in the database collection.
 
@@ -106,18 +105,18 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
             if id != updated_item.id:
                 logger.error(f"Item id {id} does not match updated item id {updated_item.id}")
                 raise ValueError(f"Item id {id} does not match updated item id {updated_item.id}")
-            await self.collection.update(updated_item)
+            self.collection.update(updated_item)
             execution_context.set_event_time(updated_item.updated_at)
             self.update_preview(updated_item)
             self.update_previews_thread()
             return updated_item
 
         except NotFoundError as e:
-            outdated_item = await self.collection.get_by_id(id)
+            outdated_item = self.collection.get_by_id(id)
             if outdated_item:
                 updated_item = outdated_item.update(new_item)
                 self.items[id] = updated_item
-                await self.collection.update(updated_item)
+                self.collection.update(updated_item)
                 execution_context.set_event_time(updated_item.updated_at)
                 self.update_previews_thread()
                 return updated_item
@@ -126,7 +125,7 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
                 f"Item with id {id} not found in {self.__class__.__name__} nor in collection DB"
             )
 
-    async def delete(self, id: str, execution_context: ExecutionContext,deletion_type : DeletionType = DeletionType.LOGICAL) -> T:
+    def delete(self, id: str, execution_context: ExecutionContext,deletion_type : DeletionType = DeletionType.LOGICAL) -> T:
         """
         Delete an item from the container and the collection.
 
@@ -143,16 +142,16 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
             deleted_item = super().delete(id)
             self.delete_preview(id)
             execution_context.set_event_time(datetime.now(ZoneInfo("UTC")))
-            await self.collection.delete(id, deletion_type)
+            self.collection.delete(id, deletion_type)
             return deleted_item
         except NotFoundError as e:
-            await self.collection.delete(id, deletion_type)
+            self.collection.delete(id, deletion_type)
             self.delete_preview(id)
             self.update_previews_thread()
             execution_context.set_event_time(datetime.now(ZoneInfo("UTC")))
-            return await self.collection.get_by_id(id)
+            return self.collection.get_by_id(id)
 
-    async def get_by_id(self, id: str) -> T:
+    def get_by_id(self, id: str) -> T:
         """
         Get an item from the container.
 
@@ -175,7 +174,7 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
             #     #if they are supposed to be in memory, we raise an error since it shouldn't be in the collection DB
             #     raise NotFoundError(f"Item with id {id} not found in {self.__class__.__name__} nor in collection DB")
             logger.debug(f"{self.__class__.__name__} getting item {id} not found in container, trying to get from collection")
-            item = await self.collection.get_by_id(id)
+            item = self.collection.get_by_id(id)
             if item:
                 if item.deleted_at is not None:
                     return item
@@ -240,7 +239,7 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
             logger.debug(f"Clearing previews cache of {self.__class__.__name__}")
             self.set_preview_items([])
 
-    async def get_all(self, company_id: Optional[StrObjectId]) -> List[T]:
+    def get_all(self, company_id: Optional[StrObjectId]) -> List[T]:
         # Get items from memory
         logger.debug(f"{self.__class__.__name__} getting all items from memory and collection")
         memory_items = super().get_all(company_id=company_id)
@@ -248,7 +247,7 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
         memory_ids = [ObjectId(item.id) for item in memory_items]
         # Build the query for collection items
         query = {"deleted_at": None, "_id": {"$nin": memory_ids}}
-        collection_items = await self.collection.get_docs(query=query, company_id=company_id)
+        collection_items = self.collection.get_docs(query=query, company_id=company_id)
         all_items = memory_items + collection_items
         return sorted(all_items, key=lambda x: x.created_at, reverse=True)
 
@@ -262,8 +261,6 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
     def update_previews_thread(self):
         """We start a thread to update the previews cache so it doesn't block the main thread"""
         # self.update_previews_cache()
-        if not self.cache_config.keep_previews_always_in_memory:
-            return
         thread = threading.Thread(target=self.update_previews_cache)
         thread.start()
 
@@ -278,13 +275,13 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
         self.set_preview_items(collection_items)
         return collection_items
 
-    async def get_by_query(self, query: dict, company_id: Optional[StrObjectId]) -> List[T]:
+    def get_by_query(self, query: dict, company_id: Optional[StrObjectId]) -> List[T]:
         logger.debug(f"{self.__class__.__name__} getting items by query {query} from collection")
-        return await self.collection.get_docs(query=query, company_id=company_id)
+        return self.collection.get_docs(query=query, company_id=company_id)
 
-    async def get_deleted(self, company_id: Optional[StrObjectId]) -> List[T]:
+    def get_deleted(self, company_id: Optional[StrObjectId]) -> List[T]:
         logger.debug(f"{self.__class__.__name__} getting deleted items from collection")
-        return await self.collection.get_docs(query={"deleted_at": {"$ne": None}}, company_id=company_id)
+        return self.collection.get_docs(query={"deleted_at": {"$ne": None}}, company_id=company_id)
 
     def load_from_db_thread(self, company_id: Optional[StrObjectId]):
         """We start a thread to load the items from the database so it doesn't block the main thread"""
@@ -295,27 +292,21 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
         thread.start()
 
     def load_from_db(self, company_id: Optional[StrObjectId]):
-        """Pass company_id=None to load all items from the database. Uses sync client for background loading."""
+        """Pass company_id=None to load all items from the database."""
         logger.debug(f"{self.__class__.__name__} loading items from collection")
-        # Background loading uses sync client (less critical, runs in thread)
-        query: Dict[str, Any] = {"deleted_at": None}
-        if company_id:
-            query["company_id"] = company_id
-        docs = list(self.collection.collection.find(filter=query))
-        # Create instances once and reuse
-        loaded_items = [self.collection.create_instance(doc) for doc in docs]
-        self.items = {item.id: item for item in loaded_items}
-
-    async def restore(self, id: str, execution_context: ExecutionContext) -> T:
+        # self.items = {item.id: item for item in self.collection.get_docs(query={}, company_id=company_id)}
+        self.items = {item.id: item for item in self.collection.get_docs(query={"deleted_at": None}, company_id=company_id)}
+
+    def restore(self, id: str, execution_context: ExecutionContext) -> T:
         logger.debug(f"{self.__class__.__name__} restoring item {id} with execution context {execution_context}")
         if id in self.items:
             raise ValueError(f"Item with id {id} already exists in {self.__class__.__name__}")
-        restored_item = await self.collection.get_by_id(id)
+        restored_item = self.collection.get_by_id(id)
         if restored_item is None:
             raise NotFoundError(f"Item with id {id} not found in collection DB")
         restored_item.deleted_at = None
         restored_item.update_now()
         execution_context.set_event_time(restored_item.updated_at)
         self.items[id] = restored_item
-        await self.collection.update(restored_item)
-        return restored_item
+        self.collection.update(restored_item)
+        return restored_item

letschatty/services/continuous_conversation_service/continuous_conversation_helper.py

@@ -269,15 +269,4 @@ class ContinuousConversationHelper:
         central_notif_content = ChattyContentCentral(body=body, status=CentralNotificationStatus.WARNING, calls_to_action=[cta.value for cta in cc.calls_to_action])
         central_notif = CentralNotificationFactory.continuous_conversation_status(cc=cc, content=central_notif_content)
         ChatService.add_central_notification(central_notification=central_notif, chat=chat)
-        return cc
-
-    @staticmethod
-    def handle_failed_template_cc(chat: Chat, cc: ContinuousConversation, error_details: str) -> ContinuousConversation:
-        """This is for the handling of a failed template CC"""
-        cc.set_status(status=ContinuousConversationStatus.FAILED)
-        body=f"Continuous conversation failed to be sent: {error_details}"
-        logger.debug(f"{body} | CC status: {cc.status} | CC id: {cc.id} | chat id: {chat.identifier}")
-        central_notif_content = ChattyContentCentral(body=body, status=CentralNotificationStatus.ERROR, calls_to_action=[cta.value for cta in cc.calls_to_action])
-        central_notif = CentralNotificationFactory.continuous_conversation_status(cc=cc, content=central_notif_content)
-        ChatService.add_central_notification(central_notification=central_notif, chat=chat)
         return cc

letschatty/services/events/events_manager.py

@@ -1,219 +1,2 @@
-"""
-Events Manager - Handles queuing and publishing events to EventBridge
+from letschatty.models.base_models.singleton import SingletonMeta
 
-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/events_factory.py

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

letschatty/services/factories/lambda_ai_orchestrartor/lambda_events_factory.py

@@ -1,27 +1,8 @@
 
 from letschatty.models import StrObjectId
-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_events import DoubleCheckerForIncomingMessagesAnswerCallbackEvent, DoubleCheckerForIncomingMessagesAnswerEvent, FixBuggedAiAgentsCallsInChatsEvent, QualityTestEventData, QualityTestsForUpdatedAIComponentEvent, QualityTestsForUpdatedAIComponentEventData
 from letschatty.models.ai_microservices.lambda_invokation_types import InvokationType
-from letschatty.models.ai_microservices import AllQualityTestEvent, AllQualityTestEventData, QualityTestEvent, QualityTestInteractionCallbackEvent, SmartTaggingCallbackEvent, QualityTestCallbackEvent, LambdaAiEvent, SmartTaggingEvent, SmartTaggingPromptEvent
+from letschatty.models.ai_microservices import AllQualityTestEvent, AllQualityTestEventData, FollowUpEvent, IncomingMessageEvent, QualityTestEvent, QualityTestInteractionCallbackEvent, SmartTaggingCallbackEvent, IncomingMessageCallbackEvent, 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
@@ -38,10 +19,16 @@ 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:
@@ -54,31 +41,6 @@ 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,4 +1,3 @@
-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
@@ -6,9 +5,9 @@ class MessageTextOrCaptionOrPreview:
         if isinstance(message_content, ChattyContentText):
             return message_content.body
         elif isinstance(message_content, ChattyContentContacts):
-            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}_"
+            return "👥 Mensaje de tipo contacto"
+        elif isinstance(message_content, ChattyContentLocation):
+            return "📍 Mensaje de tipo ubicación"
         elif isinstance(message_content, ChattyContentImage):
             return "🖼️ Mensaje de tipo imagen"
         elif isinstance(message_content, ChattyContentVideo):
@@ -23,7 +22,6 @@ 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,6 +10,10 @@ if TYPE_CHECKING:
 
 class SourcesAndTopicsValidator:
     """This class provides methods to validate sources and topics."""
+    @staticmethod
+    def normalize_source_name(name: str) -> str:
+        return name.strip().lower()
+
     @staticmethod
     def source_validation_check(sources : Dict[str,Source], topics : Dict[str,Topic], source : Source, existing_source_id : str | None = None) -> None:
         """Checks validation of a source against other sources and topics."""
@@ -28,9 +32,16 @@ class SourcesAndTopicsValidator:
         """This method checks that no duplicated source is created.
         For Pure Ads, it checks that the ad_id is unique and doesn't exist already.
         For Other Sources, it checks that exact trigger doesn't exist already. """
+        normalized_name = SourcesAndTopicsValidator.normalize_source_name(source.name)
+        existing_source_name = None
+        if existing_source_id and existing_source_id in sources:
+            existing_source_name = SourcesAndTopicsValidator.normalize_source_name(sources[existing_source_id].name)
+        should_check_name = existing_source_name is None or normalized_name != existing_source_name
         for source_id, source_to_check in sources.items():
             if source_id == existing_source_id:
                 continue
+            if should_check_name and SourcesAndTopicsValidator.normalize_source_name(source_to_check.name) == normalized_name:
+                raise ConflictedSource(f":warning: *Conflict while adding source: Name already exists* \n New source '{source.name}' \n- Id {source.id} \n Existing source '{source_to_check.name}' \n- Id {source_to_check.id}", conflicting_source_id=source_to_check.id)
             if source == source_to_check: #type: ignore
                 if isinstance(source, OtherSource):
                     raise ConflictedSource(f":warning: *Conflict while adding source: Trigger already exists* \n New source '{source.name}' \n- Id {source.id} \n- Trigger {source.trigger[:30]} \n Existing source '{source_to_check.name}' \n- Id {source_to_check.id} \n- Trigger '{source_to_check.trigger[:30]}'", conflicting_source_id=source_to_check.id)