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

letschatty/services/chatty_assets/services/ai_agent_in_chat_service.py

@@ -1,73 +0,0 @@
-"""AI Agent In Chat Service - Pre-configured AssetService for CRUD operations only"""
-
-from datetime import datetime
-from zoneinfo import ZoneInfo
-from typing import Optional
-from ..asset_service import AssetService, CacheConfig
-from ..collections.ai_agent_in_chat_collection import AIAgentInChatCollection
-from ....models.company.assets.ai_agents_v2.chatty_ai_agent_in_chat import ChattyAIAgentInChat
-from ....models.data_base.mongo_connection import MongoConnection
-from ....models.utils.types.identifier import StrObjectId
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class AIAgentInChatService(AssetService[ChattyAIAgentInChat, ChattyAIAgentInChat]):
-    """
-    Pre-configured service for AI Agent In Chat CRUD operations.
-
-    For business logic operations (set_to_processing, escalate, etc.),
-    use AIAgentInChatEditor instead.
-
-    No events needed - this is operational state, not a business asset.
-    """
-
-    def __init__(
-        self,
-        connection: MongoConnection,
-        cache_config: CacheConfig = CacheConfig(
-            keep_items_always_in_memory=False,
-            keep_previews_always_in_memory=False
-        )
-    ):
-        collection = AIAgentInChatCollection(connection)
-        super().__init__(
-            collection=collection,
-            cache_config=cache_config
-        )
-
-    collection: AIAgentInChatCollection  # Type annotation for better type checking
-
-    async def get_by_chat_id(self, chat_id: StrObjectId) -> Optional[ChattyAIAgentInChat]:
-        """Get AI agent state for a chat"""
-        return await self.collection.get_by_chat_id(chat_id)
-
-    async def update(self, ai_agent_in_chat: ChattyAIAgentInChat) -> ChattyAIAgentInChat:
-        """Update AI agent state"""
-        ai_agent_in_chat.updated_at = datetime.now(ZoneInfo("UTC"))
-        ai_agent_dict = ai_agent_in_chat.model_dump(by_alias=True, exclude_none=False)
-        # Remove _id field as it's immutable in MongoDB
-        ai_agent_dict.pop('_id', None)
-        result = await self.collection.async_collection.update_one(
-            {"chat_id": ai_agent_in_chat.chat_id},
-            {"$set": ai_agent_dict}
-        )
-        if result.matched_count == 0:
-            raise ValueError(f"AI agent state for chat {ai_agent_in_chat.chat_id} not found")
-        return ai_agent_in_chat
-
-    async def create(self, ai_agent_in_chat: ChattyAIAgentInChat) -> ChattyAIAgentInChat:
-        """Create new AI agent state"""
-        ai_agent_dict = ai_agent_in_chat.model_dump(by_alias=True, exclude_none=False)
-        result = await self.collection.async_collection.insert_one(ai_agent_dict)
-        if not result.inserted_id:
-            raise Exception(f"Failed to create AI agent state for chat {ai_agent_in_chat.chat_id}")
-        return ai_agent_in_chat
-
-    async def delete(self, chat_id: StrObjectId) -> None:
-        """Delete AI agent state"""
-        result = await self.collection.async_collection.update_one({"chat_id": chat_id}, {"$set": {"deleted_at": datetime.now(ZoneInfo("UTC"))}})
-        if result.matched_count == 0:
-            raise ValueError(f"AI agent state for chat {chat_id} not found")
-

letschatty/services/chatty_assets/services/ai_agent_service.py

@@ -1,23 +0,0 @@
-"""AI Agent Service - Pre-configured AssetService for AI Agents"""
-
-from ..asset_service import AssetService, CacheConfig
-from ..collections import AiAgentCollection
-from ....models.company.assets.ai_agents_v2.chatty_ai_agent import ChattyAIAgent, ChattyAIAgentPreview
-from ....models.data_base.mongo_connection import MongoConnection
-
-
-class AiAgentService(AssetService[ChattyAIAgent, ChattyAIAgentPreview]):
-    """Pre-configured service for AI Agent assets with sensible defaults"""
-
-    def __init__(self,
-                 connection: MongoConnection,
-                 cache_config: CacheConfig = CacheConfig(
-                     keep_items_always_in_memory=False,
-                     keep_previews_always_in_memory=True
-                 )):
-        collection = AiAgentCollection(connection)
-        super().__init__(
-            collection=collection,
-            cache_config=cache_config
-        )
-

letschatty/services/chatty_assets/services/chain_of_thought_service.py

@@ -1,70 +0,0 @@
-"""Chain Of Thought Service - Pre-configured AssetService for CRUD operations only"""
-
-from datetime import datetime
-from zoneinfo import ZoneInfo
-from typing import List, Optional
-from ..asset_service import AssetService, CacheConfig
-from ..collections.chain_of_thought_collection import ChainOfThoughtCollection
-from ....models.company.assets.ai_agents_v2.chain_of_thought_in_chat import ChainOfThoughtInChat
-from ....models.data_base.mongo_connection import MongoConnection
-from ....models.utils.types.identifier import StrObjectId
-from ....models.utils.types.serializer_type import SerializerType
-from bson import ObjectId
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class ChainOfThoughtService(AssetService[ChainOfThoughtInChat, ChainOfThoughtInChat]):
-    """
-    Pre-configured service for Chain Of Thought CRUD operations.
-
-    For business logic operations (create for N8N, set as failed, etc.),
-    use ChainOfThoughtsEditor instead.
-
-    No events needed - this is execution state, not a business asset.
-    """
-
-    def __init__(
-        self,
-        connection: MongoConnection,
-        cache_config: CacheConfig = CacheConfig(
-            keep_items_always_in_memory=False,
-            keep_previews_always_in_memory=False
-        )
-    ):
-        collection = ChainOfThoughtCollection(connection)
-        super().__init__(
-            collection=collection,
-            cache_config=cache_config
-        )
-
-    collection: ChainOfThoughtCollection  # Type annotation for better type checking
-
-    async def get_by_chat_id(self, chat_id: StrObjectId, skip: int = 0, limit: int = 10) -> List[ChainOfThoughtInChat]:
-        """Get chain of thoughts by chat ID, sorted by created_at (newest first)"""
-        return await self.collection.get_by_chat_id(chat_id=chat_id, skip=skip, limit=limit)
-
-    async def get_by_id(self, cot_id: StrObjectId) -> Optional[ChainOfThoughtInChat]:
-        """Get chain of thought by ID"""
-        return await self.collection.get_by_id(cot_id)
-
-    async def create(self, cot: ChainOfThoughtInChat) -> ChainOfThoughtInChat:
-        """Create new chain of thought"""
-        cot_dict = cot.model_dump(by_alias=True, exclude_none=False)
-        result = await self.collection.async_collection.insert_one(cot_dict)
-        if not result.inserted_id:
-            raise Exception(f"Failed to create chain of thought {cot.id}")
-        return cot
-
-    async def update(self, cot: ChainOfThoughtInChat) -> ChainOfThoughtInChat:
-        """Update chain of thought"""
-        cot.updated_at = datetime.now(ZoneInfo("UTC"))
-        cot_dict = cot.model_dump(by_alias=True, exclude_none=False)
-        result = await self.collection.async_collection.update_one(
-            {"_id": cot.id},
-            {"$set": cot_dict}
-        )
-        if result.matched_count == 0:
-            raise ValueError(f"Chain of thought {cot.id} not found")
-        return cot

letschatty/services/chatty_assets/services/chat_service.py

@@ -1,25 +0,0 @@
-"""Chat Service - Pre-configured AssetService for Chats"""
-
-from ..asset_service import AssetService, CacheConfig
-from ..collections import ChatCollection
-from ....models.chat.chat import Chat
-from ....models.base_models import ChattyAssetPreview
-from ....models.data_base.mongo_connection import MongoConnection
-
-
-class ChatService(AssetService[Chat, ChattyAssetPreview]):
-    """
-    Pre-configured service for Chat assets with sensible defaults.
-
-    Note: No event configuration - Chat events are handled by ChatsEditor, not AssetService.
-    """
-
-    def __init__(self,
-                 connection: MongoConnection,
-                 cache_config: CacheConfig = CacheConfig.default()):
-        collection = ChatCollection(connection)
-        super().__init__(
-            collection=collection,
-            cache_config=cache_config
-        )
-

letschatty/services/chatty_assets/services/contact_point_service.py

@@ -1,29 +0,0 @@
-"""Contact Point Service - Pre-configured AssetService for Contact Points"""
-
-from ..asset_service import AssetService, CacheConfig
-from ..collections import ContactPointCollection
-from ....models.company.assets.contact_point import ContactPoint
-from ....models.base_models import ChattyAssetPreview
-from ....models.data_base.mongo_connection import MongoConnection
-
-
-class ContactPointService(AssetService[ContactPoint, ChattyAssetPreview]):
-    """
-    Pre-configured service for ContactPoint assets with sensible defaults.
-
-    Note: No event configuration - ContactPoint events are managed separately by the contact points system.
-    """
-
-    def __init__(self,
-                 connection: MongoConnection,
-                 cache_config: CacheConfig = CacheConfig(
-                     keep_items_always_in_memory=False,
-                     keep_previews_always_in_memory=False,
-                     cache_expiration_time=0
-                 )):
-        collection = ContactPointCollection(connection)
-        super().__init__(
-            collection=collection,
-            cache_config=cache_config
-        )
-

letschatty/services/chatty_assets/services/fast_answer_service.py

@@ -1,32 +0,0 @@
-"""Fast Answer Service - Pre-configured AssetService for Fast Answers"""
-
-from ..asset_service import AssetService, CacheConfig
-from ..collections.fast_answer_collection import FastAnswerCollection
-from ....models.company.assets import ChattyFastAnswer
-from ....models.base_models import ChattyAssetPreview
-from ....models.data_base.mongo_connection import MongoConnection
-from ....models.analytics.events import CompanyAssetType, EventType
-
-
-class FastAnswerService(AssetService[ChattyFastAnswer, ChattyAssetPreview]):
-    """Pre-configured service for Fast Answer assets with sensible defaults"""
-
-    # Event configuration - enables automatic event handling in API
-    asset_type_enum = CompanyAssetType.FAST_ANSWERS
-    event_type_created = EventType.FAST_ANSWER_CREATED
-    event_type_updated = EventType.FAST_ANSWER_UPDATED
-    event_type_deleted = EventType.FAST_ANSWER_DELETED
-
-    def __init__(self,
-                 connection: MongoConnection,
-                 cache_config: CacheConfig = CacheConfig(
-                     keep_items_always_in_memory=False,
-                     cache_expiration_time=60*30,  # 30 minutes
-                     keep_previews_always_in_memory=True
-                 )):
-        collection = FastAnswerCollection(connection)
-        super().__init__(
-            collection=collection,
-            cache_config=cache_config
-        )
-

letschatty/services/chatty_assets/services/filter_criteria_service.py

@@ -1,30 +0,0 @@
-"""Filter Criteria Service - Pre-configured AssetService for Filter Criterias"""
-
-from ..asset_service import AssetService, CacheConfig
-from ..collections import FilterCriteriaCollection
-from ....models.company.assets.filter_criteria import FilterCriteria, FilterCriteriaPreview
-from ....models.data_base.mongo_connection import MongoConnection
-from ....models.analytics.events import CompanyAssetType, EventType
-
-
-class FilterCriteriaService(AssetService[FilterCriteria, FilterCriteriaPreview]):
-    """Pre-configured service for Filter Criteria assets with sensible defaults"""
-
-    # Event configuration - enables automatic event handling in API
-    asset_type_enum = CompanyAssetType.FILTER_CRITERIA
-    event_type_created = EventType.FILTER_CRITERIA_CREATED
-    event_type_updated = EventType.FILTER_CRITERIA_UPDATED
-    event_type_deleted = EventType.FILTER_CRITERIA_DELETED
-
-    def __init__(self,
-                 connection: MongoConnection,
-                 cache_config: CacheConfig = CacheConfig(
-                     keep_items_always_in_memory=False,
-                     keep_previews_always_in_memory=True
-                 )):
-        collection = FilterCriteriaCollection(connection)
-        super().__init__(
-            collection=collection,
-            cache_config=cache_config
-        )
-

letschatty/services/chatty_assets/services/flow_service.py

@@ -1,25 +0,0 @@
-"""Flow Service - Pre-configured AssetService for Flows"""
-
-from ..asset_service import AssetService, CacheConfig
-from ..collections import FlowCollection
-from ....models.company.assets.flow import FlowPreview
-from ....models.base_models import ChattyAssetPreview
-from ....models.data_base.mongo_connection import MongoConnection
-
-
-class FlowService(AssetService[FlowPreview, ChattyAssetPreview]):
-    """
-    Pre-configured service for Flow assets with sensible defaults.
-
-    Note: No event configuration - Flows are previews only, not full assets with CRUD events.
-    """
-
-    def __init__(self,
-                 connection: MongoConnection,
-                 cache_config: CacheConfig = CacheConfig(keep_items_always_in_memory=True)):
-        collection = FlowCollection(connection)
-        super().__init__(
-            collection=collection,
-            cache_config=cache_config
-        )
-

letschatty/services/chatty_assets/services/product_service.py

@@ -1,30 +0,0 @@
-"""Product Service - Pre-configured AssetService for Products"""
-
-from ..asset_service import AssetService, CacheConfig
-from ..collections import ProductCollection
-from ....models.company.assets.product import Product, ProductPreview
-from ....models.data_base.mongo_connection import MongoConnection
-from ....models.analytics.events import CompanyAssetType, EventType
-
-
-class ProductService(AssetService[Product, ProductPreview]):
-    """Pre-configured service for Product assets with sensible defaults"""
-
-    # Event configuration - enables automatic event handling in API
-    asset_type_enum = CompanyAssetType.PRODUCTS
-    event_type_created = EventType.PRODUCT_CREATED
-    event_type_updated = EventType.PRODUCT_UPDATED
-    event_type_deleted = EventType.PRODUCT_DELETED
-
-    def __init__(self,
-                 connection: MongoConnection,
-                 cache_config: CacheConfig = CacheConfig(
-                     keep_items_always_in_memory=False,
-                     keep_previews_always_in_memory=True
-                 )):
-        collection = ProductCollection(connection)
-        super().__init__(
-            collection=collection,
-            cache_config=cache_config
-        )
-

letschatty/services/chatty_assets/services/sale_service.py

@@ -1,25 +0,0 @@
-"""Sale Service - Pre-configured AssetService for Sales"""
-
-from ..asset_service import AssetService, CacheConfig
-from ..collections import SaleCollection
-from ....models.company.assets.sale import Sale
-from ....models.base_models import ChattyAssetPreview
-from ....models.data_base.mongo_connection import MongoConnection
-
-
-class SaleService(AssetService[Sale, ChattyAssetPreview]):
-    """
-    Pre-configured service for Sale assets with sensible defaults.
-
-    Note: No event configuration - Sale events are managed by the sales editor, not AssetService.
-    """
-
-    def __init__(self,
-                 connection: MongoConnection,
-                 cache_config: CacheConfig = CacheConfig.default()):
-        collection = SaleCollection(connection)
-        super().__init__(
-            collection=collection,
-            cache_config=cache_config
-        )
-

letschatty/services/chatty_assets/services/source_service.py

@@ -1,28 +0,0 @@
-"""Source Service - Pre-configured AssetService for Sources"""
-
-from ..asset_service import AssetService, CacheConfig
-from ..collections import SourceCollection
-from ....models.analytics.sources import SourceBase
-from ....models.base_models import ChattyAssetPreview
-from ....models.data_base.mongo_connection import MongoConnection
-from ....models.analytics.events import CompanyAssetType, EventType
-
-
-class SourceService(AssetService[SourceBase, ChattyAssetPreview]):
-    """Pre-configured service for Source assets with sensible defaults"""
-
-    # Event configuration - enables automatic event handling in API
-    asset_type_enum = CompanyAssetType.SOURCES
-    event_type_created = EventType.SOURCE_CREATED
-    event_type_updated = EventType.SOURCE_UPDATED
-    event_type_deleted = EventType.SOURCE_DELETED
-
-    def __init__(self,
-                 connection: MongoConnection,
-                 cache_config: CacheConfig = CacheConfig(keep_items_always_in_memory=True)):
-        collection = SourceCollection(connection)
-        super().__init__(
-            collection=collection,
-            cache_config=cache_config
-        )
-

letschatty/services/chatty_assets/services/tag_service.py

@@ -1,32 +0,0 @@
-"""Tag Service - Pre-configured AssetService for Tags"""
-
-from ..asset_service import AssetService, CacheConfig
-from ..collections import TagCollection
-from ....models.company.assets.tag import Tag, TagPreview
-from ....models.data_base.mongo_connection import MongoConnection
-from ....models.analytics.events import CompanyAssetType, EventType
-
-
-class TagService(AssetService[Tag, TagPreview]):
-    """Pre-configured service for Tag assets with sensible defaults"""
-
-    # Event configuration - enables automatic event handling in API
-    asset_type_enum = CompanyAssetType.TAGS
-    event_type_created = EventType.TAG_CREATED
-    event_type_updated = EventType.TAG_UPDATED
-    event_type_deleted = EventType.TAG_DELETED
-
-    def __init__(self,
-                 connection: MongoConnection,
-                 cache_config: CacheConfig = CacheConfig(
-                     keep_items_always_in_memory=False,
-                     keep_previews_always_in_memory=True
-                 )):
-        collection = TagCollection(connection)
-        super().__init__(
-            collection=collection,
-            cache_config=cache_config
-        )
-        # Load all tags into memory by default
-        self.load_from_db(company_id=None)
-

letschatty/services/chatty_assets/services/topic_service.py

@@ -1,31 +0,0 @@
-"""Topic Service - Pre-configured AssetService for Topics"""
-
-from ..asset_service import AssetService, CacheConfig
-from ..collections.topic_collection import TopicCollection
-from ....models.analytics.smart_messages.topic import Topic
-from ....models.base_models import ChattyAssetPreview
-from ....models.data_base.mongo_connection import MongoConnection
-from ....models.analytics.events import CompanyAssetType, EventType
-
-
-class TopicService(AssetService[Topic, ChattyAssetPreview]):
-    """Pre-configured service for Topic assets with sensible defaults"""
-
-    # Event configuration - enables automatic event handling in API
-    asset_type_enum = CompanyAssetType.TOPICS
-    event_type_created = EventType.TOPIC_CREATED
-    event_type_updated = EventType.TOPIC_UPDATED
-    event_type_deleted = EventType.TOPIC_DELETED
-
-    def __init__(self,
-                 connection: MongoConnection,
-                 cache_config: CacheConfig = CacheConfig(
-                     keep_items_always_in_memory=True,
-                     keep_previews_always_in_memory=True
-                 )):
-        collection = TopicCollection(connection)
-        super().__init__(
-            collection=collection,
-            cache_config=cache_config
-        )
-

letschatty/services/chatty_assets/services/user_service.py

@@ -1,32 +0,0 @@
-"""User Service - Pre-configured AssetService for Users"""
-
-from ..asset_service import AssetService, CacheConfig
-from ..collections import UserCollection
-from ....models.company.assets.users.user import User, UserPreview
-from ....models.data_base.mongo_connection import MongoConnection
-from ....models.analytics.events import CompanyAssetType, EventType
-
-
-class UserService(AssetService[User, UserPreview]):
-    """Pre-configured service for User assets with sensible defaults"""
-
-    # Event configuration - enables automatic event handling in API
-    asset_type_enum = CompanyAssetType.USERS
-    event_type_created = EventType.USER_CREATED
-    event_type_updated = EventType.USER_UPDATED
-    event_type_deleted = EventType.USER_DELETED
-
-    def __init__(self,
-                 connection: MongoConnection,
-                 cache_config: CacheConfig = CacheConfig(
-                     keep_items_always_in_memory=False,
-                     cache_expiration_time_previews=300,
-                     keep_previews_always_in_memory=True,
-                     keep_deleted_previews_in_memory=True
-                 )):
-        collection = UserCollection(connection)
-        super().__init__(
-            collection=collection,
-            cache_config=cache_config
-        )
-

letschatty/services/events/__init__.py

@@ -1,6 +0,0 @@
-"""Events management services"""
-
-from .events_manager import EventsManager, events_manager
-
-__all__ = ['EventsManager', 'events_manager']
-

letschatty/services/factories/analytics/ai_agent_event_factory.py

@@ -1,161 +0,0 @@
-"""
-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))
-