letschatty 0.4.338__py3-none-any.whl → 0.4.350__py3-none-any.whl

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

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

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

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

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

@@ -5,11 +5,17 @@ Defines the data collection, acceptance criteria, and destination actions
 for qualifying/disqualifying users.
 """
 
+from letschatty.models.company.assets.automation import Automation
 from pydantic import BaseModel, Field
 from typing import Optional, List
 from enum import StrEnum
 from letschatty.models.utils.types.identifier import StrObjectId
 
+class PostToExternalApiConfig(BaseModel):
+    """Placeholder provisorio"""
+    url: str = Field(description="The URL to post to")
+    method: str = Field(description="The HTTP method to use")
+    api_key: str
 
 class PreQualifyDestination(StrEnum):
     """
@@ -18,9 +24,22 @@ class PreQualifyDestination(StrEnum):
     SUBSCRIBE_TO_LAUNCH = "subscribe_to_launch"  # Subscribe to launch + welcome kit
     CALENDAR_SCHEDULER = "calendar_scheduler"    # Allow AI agent to schedule meetings
     ESCALATE = "escalate"                        # Escalate to human
+    AUTO_ASSIGN_HUMAN_AGENT = "auto_assign_human_agent"  # Auto-assign human agent
     CUSTOM_MESSAGE = "custom_message"            # Send a custom message
+    AUTO_ASSIGN_HUMAN_AGENT = "auto_assign_human_agent" #
     CONTINUE = "continue"                        # Continue normal AI agent flow
     NONE = "none"                                # Do nothing
+    ARCHIVE = "archive"                          # Archive chat
+    POST_TO_EXTERNAL_API = "post_to_external_api"  # Post result to external API
+
+
+class PostToExternalApiConfig(BaseModel):
+    """
+    Configuration for posting pre-qualification results to an external API.
+    """
+    url: str = Field(description="Target URL for the external API")
+    method: str = Field(default="POST", description="HTTP method to use")
+    api_key: Optional[str] = Field(default=None, description="Optional API key for authentication")
 
 
 class PreQualifyFormField(BaseModel):
@@ -68,6 +87,16 @@ class PreQualifyConfig(BaseModel):
         default=None,
         description="Custom message to send when user does NOT qualify (if destination is custom_message or escalate)"
     )
+    post_to_external_api : Optional[PostToExternalApiConfig] = Field(
+        default=None,
+        description="Configuration for posting to an external API"
+    )
+
+    # Optional external API destination config
+    post_to_external_api: Optional[PostToExternalApiConfig] = Field(
+        default=None,
+        description="Config for POST_TO_EXTERNAL_API destination"
+    )
 
     @property
     def has_form_fields(self) -> bool:
@@ -108,4 +137,3 @@ class PreQualifyConfig(BaseModel):
         original_len = len(self.form_fields)
         self.form_fields = [f for f in self.form_fields if f.field_key != field_key]
         return len(self.form_fields) < original_len
-

letschatty/models/company/assets/automation.py

@@ -14,18 +14,27 @@ class Automation(BaseModel):
     chatty_ai_agent_config: Optional[ChattyAIConfigForAutomation] = Field(default=None)
     area: Optional[Area] = Field(default=None)
     agent_id: Optional[StrObjectId] = Field(default=None)
-    chain_of_thought: Optional[str] = Field(default=None)
-    # Funnel transition automations
-    target_funnel_id: Optional[StrObjectId] = Field(
-        default=None,
-        description="Target funnel to move the chat to (for cross-funnel transitions)"
-    )
-    target_stage_id: Optional[StrObjectId] = Field(
-        default=None,
-        description="Target stage within the target funnel"
-    )
+    chain_of_thought : Optional[str] = Field(default=None)
     # client_info: Optional[ClientInfo] = Field(default=None) me gustaría que levante el mail y/o otros atributos
 
+    @property
+    def has_automation(self) -> bool:
+        """
+        Check if there's an actual automation defined (tags, products, or flow).
+
+        Returns:
+            bool: True if there's at least one tag, product, or flow defined
+        """
+        return (
+            len(self.tags) > 0 or
+            len(self.products) > 0 or
+            len(self.flow) > 0 or
+            self.quality_score is not None or
+            self.chatty_ai_agent_config is not None or
+            self.area is not None or
+            self.highlight_description is not None
+        )
+
     @model_validator(mode='after')
     def check_agent_id(self):
         if self.area == Area.WITH_AGENT and not self.agent_id:

letschatty/models/company/assets/company_assets.py

@@ -5,8 +5,6 @@ class CompanyAssetType(StrEnum):
     USERS = "users"
     BUSINESS_AREAS = "business_areas"
     FUNNELS = "funnels"
-    FUNNEL_STAGES = "funnel_stages"
-    FUNNEL_MEMBERS = "funnel_members"
     PRODUCTS = "products"
     SALES = "sales"
     TAGS = "tags"

letschatty/models/data_base/collection_interface.py

@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING, Dict, List, Generic, TypeVar, Type, Optional,
 from bson.objectid import ObjectId
 from pymongo.collection import Collection
 from pymongo.database import Database
+from motor.motor_asyncio import AsyncIOMotorDatabase, AsyncIOMotorCollection
 
 from letschatty.models.chat.chat import Chat
 from ...models.base_models.chatty_asset_model import ChattyAssetModel, CompanyAssetModel, ChattyAssetPreview
@@ -26,58 +27,116 @@ P = TypeVar('P', bound=ChattyAssetPreview)
 class ChattyAssetCollectionInterface(Generic[T, P], ABC):
     def __init__(self, database: str, collection: str, connection: MongoConnection, type: Type[T], preview_type: Optional[Type[P]] = None):
         logger.info(f"Initializing collection {collection} in database {database}")
+        # Sync database and collection (existing)
         self.db: Database = connection.client[database]
         self.collection: Collection = connection.client[database][collection]
+
+        # NEW: Async database and collection
+        # Store connection reference to ensure we use current event loop
+        self._connection = connection
+        self._database_name = database
+        self._collection_name = collection
+        self._async_db: Optional[AsyncIOMotorDatabase] = None
+        self._async_collection: Optional[AsyncIOMotorCollection] = None
+
         self.type = type
         self.preview_type = preview_type
+
+    @property
+    def async_db(self) -> AsyncIOMotorDatabase:
+        """Get async database, ensuring it uses the current event loop"""
+        # Always ensure connection's async client is using current loop (for Lambda compatibility)
+        self._connection._ensure_async_client_loop()
+        # Recreate database reference to ensure it uses the current client
+        self._async_db = self._connection.async_client[self._database_name]
+        return self._async_db
+
+    @property
+    def async_collection(self) -> AsyncIOMotorCollection:
+        """Get async collection, ensuring it uses the current event loop"""
+        # Always ensure connection's async client is using current loop (for Lambda compatibility)
+        self._connection._ensure_async_client_loop()
+        # Recreate collection reference to ensure it uses the current client
+        self._async_collection = self._connection.async_client[self._database_name][self._collection_name]
+        return self._async_collection
     @abstractmethod
     def create_instance(self, data: dict) -> T:
         """Factory method to create instance from data"""
         pass
 
-    def insert(self, asset: T) -> StrObjectId:
+    # All methods are now async-only for better performance
+    async def insert(self, asset: T) -> StrObjectId:
+        """Async insert operation"""
         if not isinstance(asset, self.type):
             raise ValueError(f"Asset must be of type {self.type.__name__}")
         document = asset.model_dump_json(serializer=SerializerType.DATABASE)
         logger.debug(f"Inserting document: {document}")
-        result = self.collection.insert_one(document)
+        result = await self.async_collection.insert_one(document)
         if not result.inserted_id:
             raise Exception("Failed to insert document")
         logger.debug(f"Inserted document with id {result.inserted_id}")
         return result.inserted_id
 
-    def update(self, asset: T) -> StrObjectId:
+    async def update(self, asset: T) -> StrObjectId:
+        """Async update operation"""
         logger.debug(f"Updating document with id {asset.id}")
         if not isinstance(asset, self.type):
             raise ValueError(f"Asset must be of type {self.type.__name__}")
         asset.update_now()
         document = asset.model_dump_json(serializer=SerializerType.DATABASE)
-        document.pop('_id', None)  # Still needed
-        result = self.collection.update_one({"_id": ObjectId(asset.id)}, {"$set": document})
+        document.pop('_id', None)
+        result = await self.async_collection.update_one(
+            {"_id": ObjectId(asset.id)},
+            {"$set": document}
+        )
         if result.matched_count == 0:
             raise NotFoundError(f"No document found with id {asset.id}")
         if result.modified_count == 0:
             logger.debug(f"No changes were made to the document with id {asset.id} probably because the values were the same")
         return asset.id
 
-    def get_by_id(self, doc_id: str) -> T:
-        logger.debug(f"Getting document with id {doc_id} from collection {self.collection.name} and db {self.db.name}")
-        doc = self.collection.find_one({"_id": ObjectId(doc_id)})
-
+    async def get_by_id(self, doc_id: str) -> T:
+        """Get by ID operation"""
+        logger.debug(f"Getting document with id {doc_id} from collection {self.async_collection.name}")
+        doc = await self.async_collection.find_one({"_id": ObjectId(doc_id)})
         if doc:
             return self.create_instance(doc)
         else:
-            raise NotFoundError(f"No document found with id {doc_id} in db collection {self.collection.name} and db {self.db.name}")
+            raise NotFoundError(f"No document found with id {doc_id} in collection")
 
-    def get_docs(self, company_id:Optional[StrObjectId], query = {}, limit = 0) -> List[T]:
-        logger.debug(f"Getting documents from collection {self.collection.name} with company_id {company_id} and query {query}")
+    async def get_docs(self, company_id: Optional[StrObjectId], query={}, limit=0) -> List[T]:
+        """Get multiple documents operation"""
+        logger.debug(f"Getting documents from collection with company_id {company_id} and query {query}")
         if company_id:
-            query = query.copy()  # Create a copy to avoid modifying the original
+            query = query.copy()
             query["company_id"] = company_id
-        docs = list(self.collection.find(filter=query).limit(limit))
-        logger.debug(f"Found {len(docs)} documents in collection {self.collection.name}")
+        cursor = self.async_collection.find(filter=query)
+        if limit:
+            cursor = cursor.limit(limit)
+        docs = await cursor.to_list(length=limit if limit > 0 else None)
+        logger.debug(f"Found {len(docs)} documents")
         return [self.create_instance(doc) for doc in docs]
 
+    async def delete(self, doc_id: str, deletion_type: DeletionType = DeletionType.LOGICAL) -> StrObjectId:
+        """Delete operation"""
+        logger.debug(f"Deleting document with id {doc_id} - deletion type: {deletion_type}")
+        if deletion_type == DeletionType.LOGICAL:
+            result = await self.async_collection.update_one(
+                {"_id": ObjectId(doc_id)},
+                {"$set": {"deleted_at": datetime.now(ZoneInfo("UTC")), "updated_at": datetime.now(ZoneInfo("UTC"))}}
+            )
+            if result.modified_count == 0:
+                raise NotFoundError(f"No document found with id {doc_id}")
+            return doc_id
+        elif deletion_type == DeletionType.PHYSICAL:
+            result = await self.async_collection.delete_one({"_id": ObjectId(doc_id)})
+            if result.deleted_count == 0:
+                raise NotFoundError(f"No document found with id {doc_id}")
+            return doc_id
+        else:
+            raise ValueError(f"Invalid deletion type: {deletion_type}")
+
+    # Additional methods - keeping these sync as they're less critical
     def get_preview_docs(self, projection = {}, all=True) -> List[P]:
         """We get the previews of all the documents in the collection for all companies"""
         if not self.preview_type:
@@ -98,18 +157,31 @@ class ChattyAssetCollectionInterface(Generic[T, P], ABC):
         docs = self.collection.find(query)
         return [self.create_instance(doc) for doc in docs]
 
-    def delete(self, doc_id: str, deletion_type : DeletionType = DeletionType.LOGICAL) -> StrObjectId:
-        logger.debug(f"Deleting document with id {doc_id} - deletion type: {deletion_type}")
-        if deletion_type == DeletionType.LOGICAL:
-            result = self.collection.update_one({"_id": ObjectId(doc_id)}, {"$set": {"deleted_at": datetime.now(ZoneInfo("UTC")), "updated_at": datetime.now(ZoneInfo("UTC"))}})
-            if result.modified_count == 0:
-                raise NotFoundError(f"No document found with id {doc_id}")
-            return doc_id
-        elif deletion_type == DeletionType.PHYSICAL:
-            result = self.collection.delete_one({"_id": ObjectId(doc_id)})
-            if result.deleted_count == 0:
-                raise NotFoundError(f"No document found with id {doc_id}")
-            return doc_id
-        else:
-            raise ValueError(f"Invalid deletion type: {deletion_type}")
+    async def get_by_ids(self, ids: List[StrObjectId]) -> List[T]:
+            """
+            Get multiple assets by their IDs in a single query.
+
+            Args:
+                ids: List of asset IDs
+
+            Returns:
+                List of assets objects
+            """
+            if not ids:
+                return []
+
+            # Convert string IDs to ObjectIds
+            object_ids = [ObjectId(id) for id in ids]
+
+            # Query for all filter criteria with matching IDs
+            query = {
+                "_id": {"$in": object_ids},
+                "deleted_at": None
+            }
+
+            # Use the sync collection directly (inherited from ChattyAssetCollectionInterface)
+            docs = await self.async_collection.find(query).to_list(length=None)
+
+            # Create FilterCriteria instances
+            return [self.create_instance(doc) for doc in docs]
 

letschatty/models/data_base/mongo_connection.py

@@ -1,8 +1,14 @@
 from ..base_models.singleton import SingletonMeta
 from pymongo import MongoClient
+from motor.motor_asyncio import AsyncIOMotorClient
 from typing import Optional
+from urllib.parse import quote_plus
 import os
 import atexit
+import asyncio
+import logging
+
+logger = logging.getLogger(__name__)
 
 class MongoConnection(metaclass=SingletonMeta):
     def __init__(
@@ -10,26 +16,103 @@ class MongoConnection(metaclass=SingletonMeta):
         username: Optional[str] = None,
         password: Optional[str] = None,
         uri_base: Optional[str] = None,
-        instance: Optional[str] = None
+        instance: Optional[str] = None,
+        verify_on_init: bool = True
     ):
         self.username = username or os.getenv('MONGO_USERNAME')
         self.password = password or os.getenv('MONGO_PASSWORD')
         self.uri_base = uri_base or os.getenv('MONGO_URI_BASE')
         self.instance = instance or os.getenv('MONGO_INSTANCE_COMPONENT')
-        
+
         if not all([self.username, self.password, self.uri_base, self.instance]):
             raise ValueError("Missing required MongoDB connection parameters")
-            
-        uri = f"{self.uri_base}://{self.username}:{self.password}@{self.instance}.mongodb.net"
+
+        # URL-encode username and password to handle special characters per RFC 3986
+        encoded_username = quote_plus(self.username)
+        encoded_password = quote_plus(self.password)
+
+        uri = f"{self.uri_base}://{encoded_username}:{encoded_password}@{self.instance}.mongodb.net"
+
+        # Sync client (existing)
         self.client = MongoClient(uri)
+
+        # NEW: Async client for async operations
+        # Don't pass io_loop - Motor will automatically use the current event loop
+        # This is important for Lambda where the event loop changes between invocations
+        self.async_client = AsyncIOMotorClient(uri)
+
+        # Verify connections if requested
+        if verify_on_init:
+            try:
+                # Try to get running loop
+                loop = asyncio.get_running_loop()
+                # If we get here, there's a running loop
+                logger.warning(
+                    "Event loop is already running. Skipping connection verification in __init__. "
+                    "Call verify_connection_async() from async context to verify connection."
+                )
+                self._connection_verified = False
+            except RuntimeError:
+                # No running loop, safe to use run_until_complete
+                try:
+                    # Test sync client
+                    self.client.admin.command('ping')
+
+                    # Test async client in sync context
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+                    loop.run_until_complete(self.async_client.admin.command('ping'))
+                    self._connection_verified = True
+                    loop.close()
+                except Exception as e:
+                    self.client.close()
+                    self.async_client.close()
+                    raise ConnectionError(f"Failed to connect to MongoDB: {str(e)}")
+        else:
+            self._connection_verified = False
+
+        atexit.register(self.close)
+
+    def _ensure_async_client_loop(self):
+        """Ensure async client is using the current event loop (for Lambda compatibility)"""
         try:
-            self.client.admin.command('ping')
+            current_loop = asyncio.get_running_loop()
+            # Check if client's loop is closed or different
+            client_loop = getattr(self.async_client, '_io_loop', None)
+            if client_loop is not None:
+                try:
+                    # Try to check if the loop is closed
+                    if client_loop.is_closed():
+                        # Recreate client with current loop
+                        logger.warning("Async client's event loop is closed, recreating client")
+                        old_client = self.async_client
+                        uri = f"{self.uri_base}://{quote_plus(self.username)}:{quote_plus(self.password)}@{self.instance}.mongodb.net"
+                        self.async_client = AsyncIOMotorClient(uri)
+                        try:
+                            old_client.close()
+                        except:
+                            pass
+                except AttributeError:
+                    # _io_loop might not exist in newer Motor versions
+                    pass
+        except RuntimeError:
+            # No running loop, which is fine - Motor will handle it
+            pass
+
+    async def verify_connection_async(self) -> bool:
+        """Verify MongoDB connection asynchronously. Safe to call from async context."""
+        try:
+            # Ensure we're using the current event loop
+            self._ensure_async_client_loop()
+            await self.async_client.admin.command('ping')
+            self._connection_verified = True
+            return True
         except Exception as e:
-            self.client.close()
-            raise ConnectionError(f"Failed to connect to MongoDB: {str(e)}")
+            logger.error(f"Failed to verify MongoDB connection: {e}")
+            raise ConnectionError(f"Failed to verify MongoDB connection: {e}")
 
-        atexit.register(self.close)
-    
     def close(self) -> None:
         if hasattr(self, 'client'):
             self.client.close()
+        if hasattr(self, 'async_client'):
+            self.async_client.close()

letschatty/models/messages/chatty_messages/schema/chatty_content/content_document.py

@@ -1,6 +1,5 @@
 from pydantic import BaseModel, Field, model_validator, ValidationInfo
 from typing import Optional
-from urllib.parse import urlparse, unquote
 from .content_media import ChattyContentMedia
 
 class ChattyContentDocument(ChattyContentMedia):
@@ -9,6 +8,5 @@ class ChattyContentDocument(ChattyContentMedia):
     @model_validator(mode='before')
     def validate_filename(cls, data: dict, info: ValidationInfo):
         if not data.get("filename") and data.get("url"):
-            parsed = urlparse(data["url"])
-            data["filename"] = unquote(parsed.path.split("/")[-1])
-        return data
+            data["filename"] = data["url"].split("/")[-1]
+        return data

letschatty/models/messages/chatty_messages/schema/chatty_content/content_media.py

@@ -1,6 +1,5 @@
 from pydantic import BaseModel, Field, field_validator, HttpUrl
 from typing import Optional
-from urllib.parse import quote
 class ChattyContentMedia(BaseModel):
     id: Optional[str] = Field(description="Unique identifier for the image. Also known as media_id", default="")
     url: str = Field(description="URL of the media from S3")
@@ -12,9 +11,9 @@ class ChattyContentMedia(BaseModel):
     def validate_url(cls, v):
         if not v:
             raise ValueError("URL is required")
-        encoded = quote(str(v), safe=":/?&=%#")
-        HttpUrl(encoded)
-        return encoded
+        HttpUrl(v)
+        return v
     
     def get_body_or_caption(self) -> str:
         return self.caption
+

letschatty/models/utils/custom_exceptions/custom_exceptions.py

@@ -5,6 +5,7 @@ import json
 from datetime import timedelta
 
 from letschatty.models.utils.definitions import Area
+from pydantic_core.core_schema import custom_error_schema
 logger = logging.getLogger("logger")
 
 class Context(BaseModel):
@@ -229,4 +230,16 @@ class OpenAIError(CustomException):
 
 class NewerAvailableMessageToBeProcessedByAiAgent(CustomException):
     def __init__(self, message="Duplicated incoming message call for ai agent", status_code=400, **context_data):
-        super().__init__(message, status_code=status_code, **context_data)
+        super().__init__(message, status_code=status_code, **context_data)
+
+class MissingAIAgentInChat(CustomException):
+    def __init__(self, message="Missing AI agent in chat", status_code=400, **context_data):
+        super().__init__(message, status_code=status_code, **context_data)
+
+class ChattyAIModeOff(CustomException):
+    def __init__(self, message="Chatty AI agent is in OFF mode", status_code=400, **context_data):
+        super().__init__(message, status_code=status_code, **context_data)
+
+class ChatWithActiveContinuousConversation(CustomException):
+    def __init__(self, message="Chat has active continuous conversation", status_code=400, **context_data):
+        super().__init__(message, status_code=status_code, **context_data)

letschatty/services/ai_agents/smart_follow_up_context_builder_v2.py

@@ -14,13 +14,16 @@ class SmartFollowUpContextBuilder(ContextBuilder):
 
     @staticmethod
     def check_minimum_time_since_last_message(chat: Chat, follow_up_strategy: FollowUpStrategy,smart_follow_up_state: FlowStateAssignedToChat) -> bool:
-        expected_interval_minutes = follow_up_strategy.get_interval_for_followup(smart_follow_up_state.consecutive_count)
+        # consecutive_count is 0-indexed (0 = no follow-ups sent yet), but get_interval_for_followup expects 1-indexed
+        # So we add 1 to get the interval for the follow-up we're about to send
+        next_followup_number = smart_follow_up_state.consecutive_count + 1
+        expected_interval_minutes = follow_up_strategy.get_interval_for_followup(next_followup_number)
         last_message_timestamp = chat.last_message_timestamp
         if last_message_timestamp is None:
             raise HumanInterventionRequired("There's no last message in the chat, can't validate the minimum time since last message for the smart follow up")
         time_since_last_message = datetime.now(ZoneInfo('UTC')) - last_message_timestamp
         if time_since_last_message.total_seconds() < expected_interval_minutes * 60:
-            raise PostponeFollowUp(time_delta= timedelta(seconds=expected_interval_minutes * 60 - time_since_last_message.total_seconds()), message=f"Se pospuso el Smart Follow Up porque no ha pasado el tiempo mínimo esperado de {expected_interval_minutes/60} horas para el seguimiento #{smart_follow_up_state.consecutive_count}")
+            raise PostponeFollowUp(time_delta= timedelta(seconds=expected_interval_minutes * 60 - time_since_last_message.total_seconds()), message=f"Se pospuso el Smart Follow Up porque no ha pasado el tiempo mínimo esperado de {expected_interval_minutes/60} horas para el seguimiento #{next_followup_number}")
         return True
 
 

letschatty/services/chatty_assets/__init__.py

@@ -1,2 +1,14 @@
 from .base_container import ChattyAssetBaseContainer
 from .base_container_with_collection import ChattyAssetContainerWithCollection
+from .assets_collections import AssetsCollections
+from .services import (
+    ProductService,
+    TagService,
+    UserService,
+    ChatService,
+    SourceService,
+    FlowService,
+    SaleService,
+    ContactPointService,
+    AiAgentService
+)