letschatty 0.4.342__py3-none-any.whl → 0.4.344__py3-none-any.whl

letschatty/models/company/empresa.py

@@ -1,3 +1,4 @@
+from letschatty.models.company.integrations.shopify.company_shopify_integration import ShopifyIntegration
 from pydantic import Field, ConfigDict, field_validator, SecretStr, model_validator
 from typing import Optional, List, Dict
 
@@ -34,7 +35,7 @@ class EmpresaModel(ChattyAssetModel):
     continuous_conversation_template_name: Optional[str] = Field(default = None, description="The name of the continuous conversation template")
     default_follow_up_strategy_id: Optional[StrObjectId] = Field(default = None, description="The id of the default follow up strategy")
     messaging_settings: MessagingSettings = Field(default = MessagingSettings(), description="The messaging settings for the company")
-
+    shopify_integration: ShopifyIntegration = Field(default = ShopifyIntegration(), description="The Shopify integration for the company")
 
     model_config = ConfigDict(
         validate_by_name=True,

letschatty/models/company/integrations/product_sync_status.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import ClassVar, Optional
+
+from pydantic import Field
+
+from letschatty.models.company.integrations.sync_status_enum import SyncStatusEnum
+from letschatty.models.base_models import CompanyAssetModel
+
+
+class ProductSyncStatus(CompanyAssetModel):
+    """Generic product sync status for any e-commerce integration."""
+
+    COLLECTION: ClassVar[str] = "product_sync_statuses"
+
+    integration_type: str = Field(
+        description="Integration type (shopify, tiendanube, etc.)"
+    )
+    status: SyncStatusEnum = Field(description="Current sync status")
+
+    products_created: int = Field(default=0)
+    products_updated: int = Field(default=0)
+
+    name: str = Field(default="")
+
+    finished_at: Optional[datetime] = Field(default=None)
+

letschatty/models/company/integrations/shopify/company_shopify_integration.py

@@ -0,0 +1,62 @@
+from typing import List, Optional
+from datetime import datetime
+from zoneinfo import ZoneInfo
+from pydantic import BaseModel, Field
+
+class ShopifyWebhookSubscription(BaseModel):
+    """Represents a single webhook subscription"""
+    topic: str = Field(description="Webhook topic (e.g., 'products/create')")
+    webhook_id: Optional[str] = Field(default=None, description="Shopify webhook ID")
+    subscribed_at: datetime = Field(default_factory=lambda: datetime.now(tz=ZoneInfo("UTC")))
+    is_active: bool = Field(default=True, description="Whether subscription is active")
+
+class ShopifyIntegration(BaseModel):
+    """Shopify integration for the company"""
+    shopify_store_url: str = Field(default="")
+    oauth_state: str = Field(default="")
+    oauth_state_at: datetime = Field(default_factory=lambda: datetime.now(tz=ZoneInfo("UTC")))
+    access_token: Optional[str] = Field(default=None)
+    connected_at: Optional[datetime] = Field(default=None)
+    scope: Optional[str] = Field(default=None)
+    
+    # Webhook subscriptions
+    webhook_subscriptions: List[ShopifyWebhookSubscription] = Field(
+        default_factory=list,
+        description="List of active webhook subscriptions"
+    )
+    
+    # Scheduled sync settings
+    product_sync_enabled: bool = Field(
+        default=False,
+        description="Whether scheduled product sync is enabled"
+    )
+    product_sync_interval_hours: int = Field(
+        default=24,
+        description="Interval in hours for scheduled product sync"
+    )
+    last_product_sync_at: Optional[datetime] = Field(
+        default=None,
+        description="Timestamp of last product sync"
+    )
+    
+    @property
+    def is_connected(self) -> bool:
+        """Check if the integration is fully connected"""
+        return bool(self.access_token and self.shopify_store_url)
+    
+    def get_subscribed_topics(self) -> List[str]:
+        """Get list of currently subscribed webhook topics"""
+        return [sub.topic for sub in self.webhook_subscriptions if sub.is_active]
+    
+    def reset(self) -> None:
+        """Reset integration to disconnected state"""
+        self.shopify_store_url = ""
+        self.oauth_state = ""
+        self.oauth_state_at = datetime.now(tz=ZoneInfo("UTC"))
+        self.access_token = None
+        self.connected_at = None
+        self.scope = None
+        self.webhook_subscriptions = []
+        self.product_sync_enabled = False
+        self.product_sync_interval_hours = 24
+        self.last_product_sync_at = None

letschatty/models/company/integrations/shopify/shopify_product_sync_status.py

@@ -1,42 +1,18 @@
-from enum import Enum
-from typing import Optional
-from datetime import datetime
-from zoneinfo import ZoneInfo
 from pydantic import Field
-from letschatty.models.base_models import CompanyAssetModel
 
+from letschatty.models.company.integrations.product_sync_status import ProductSyncStatus
+from letschatty.models.company.integrations.sync_status_enum import SyncStatusEnum
 
-class ShopifyProductSyncStatusEnum(str, Enum):
-    """Status enum for Shopify product sync operations"""
-    STARTED = "started"
-    RUNNING = "running"
-    FINISHED = "finished"
-    FAILED = "failed"
 
+# Backwards-compatible alias (Shopify-specific name, generic enum)
+ShopifyProductSyncStatusEnum = SyncStatusEnum
 
-class ShopifyProductSyncStatus(CompanyAssetModel):
-    """Tracks the status and results of Shopify product synchronization operations.
-    
-    Each sync operation creates a new document in the collection with its own status,
-    timestamps, and product counts.
-    """
-    name: str = Field(
-        default="",
-        description="Name/identifier for this sync operation"
-    )
-    status: ShopifyProductSyncStatusEnum = Field(
-        default=ShopifyProductSyncStatusEnum.STARTED,
-        description="Current sync status"
-    )
-    finished_at: Optional[datetime] = Field(
-        default=None,
-        description="Timestamp when sync finished"
-    )
-    products_created: int = Field(
-        default=0,
-        description="Number of products created during sync"
-    )
-    products_updated: int = Field(
-        default=0,
-        description="Number of products updated during sync"
+
+class ShopifyProductSyncStatus(ProductSyncStatus):
+    """Shopify-flavored wrapper for the generic ProductSyncStatus."""
+
+    integration_type: str = Field(
+        default="shopify",
+        frozen=True,
+        description="Integration type for this sync status"
     )

letschatty/models/company/integrations/shopify/shopify_webhook_topics.py

@@ -0,0 +1,40 @@
+from enum import Enum
+
+class ShopifyWebhookTopic(str, Enum):
+    """Shopify webhook topics for products and orders"""
+    
+    # Product webhooks
+    PRODUCTS_CREATE = "products/create"
+    PRODUCTS_UPDATE = "products/update"
+    PRODUCTS_DELETE = "products/delete"
+    
+    # Order webhooks
+    ORDERS_CREATE = "orders/create"
+    ORDERS_UPDATE = "orders/updated"
+    ORDERS_DELETE = "orders/delete"
+    ORDERS_FULFILLED = "orders/fulfilled"
+    ORDERS_PARTIALLY_FULFILLED = "orders/partially_fulfilled"
+    ORDERS_PAID = "orders/paid"
+    ORDERS_CANCELLED = "orders/cancelled"
+    
+    @classmethod
+    def get_product_topics(cls) -> list[str]:
+        """Get all product-related webhook topics"""
+        return [
+            cls.PRODUCTS_CREATE.value,
+            cls.PRODUCTS_UPDATE.value,
+            cls.PRODUCTS_DELETE.value,
+        ]
+    
+    @classmethod
+    def get_order_topics(cls) -> list[str]:
+        """Get all order-related webhook topics"""
+        return [
+            cls.ORDERS_CREATE.value,
+            cls.ORDERS_UPDATE.value,
+            cls.ORDERS_DELETE.value,
+            cls.ORDERS_FULFILLED.value,
+            cls.ORDERS_PARTIALLY_FULFILLED.value,
+            cls.ORDERS_PAID.value,
+            cls.ORDERS_CANCELLED.value,
+        ]

letschatty/models/company/integrations/sync_status_enum.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class SyncStatusEnum(str, Enum):
+    STARTED = "STARTED"
+    RUNNING = "RUNNING"
+    FINISHED = "FINISHED"
+    FAILED = "FAILED"
+

letschatty/models/data_base/collection_interface.py

@@ -4,7 +4,6 @@ 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
@@ -27,116 +26,58 @@ 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
 
-    # All methods are now async-only for better performance
-    async def insert(self, asset: T) -> StrObjectId:
-        """Async insert operation"""
+    def insert(self, asset: T) -> StrObjectId:
         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 = await self.async_collection.insert_one(document)
+        result = self.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
 
-    async def update(self, asset: T) -> StrObjectId:
-        """Async update operation"""
+    def update(self, asset: T) -> StrObjectId:
         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)
-        result = await self.async_collection.update_one(
-            {"_id": ObjectId(asset.id)},
-            {"$set": document}
-        )
+        document.pop('_id', None)  # Still needed
+        result = self.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
 
-    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)})
+    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)})
+
         if doc:
             return self.create_instance(doc)
         else:
-            raise NotFoundError(f"No document found with id {doc_id} in collection")
+            raise NotFoundError(f"No document found with id {doc_id} in db collection {self.collection.name} and db {self.db.name}")
 
-    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}")
+    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}")
         if company_id:
-            query = query.copy()
+            query = query.copy()  # Create a copy to avoid modifying the original
             query["company_id"] = company_id
-        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")
+        docs = list(self.collection.find(filter=query).limit(limit))
+        logger.debug(f"Found {len(docs)} documents in collection {self.collection.name}")
         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:
@@ -157,31 +98,18 @@ class ChattyAssetCollectionInterface(Generic[T, P], ABC):
         docs = self.collection.find(query)
         return [self.create_instance(doc) for doc in docs]
 
-    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]
+    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}")
 

letschatty/models/data_base/mongo_connection.py

@@ -1,14 +1,8 @@
 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__(
@@ -16,103 +10,26 @@ class MongoConnection(metaclass=SingletonMeta):
         username: Optional[str] = None,
         password: Optional[str] = None,
         uri_base: Optional[str] = None,
-        instance: Optional[str] = None,
-        verify_on_init: bool = True
+        instance: Optional[str] = None
     ):
         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")
-
-        # 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)
+            
+        uri = f"{self.uri_base}://{self.username}:{self.password}@{self.instance}.mongodb.net"
         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:
-            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
+            self.client.admin.command('ping')
         except Exception as e:
-            logger.error(f"Failed to verify MongoDB connection: {e}")
-            raise ConnectionError(f"Failed to verify MongoDB connection: {e}")
+            self.client.close()
+            raise ConnectionError(f"Failed to connect to MongoDB: {str(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,5 +1,6 @@
 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):
@@ -8,5 +9,6 @@ class ChattyContentDocument(ChattyContentMedia):
     @model_validator(mode='before')
     def validate_filename(cls, data: dict, info: ValidationInfo):
         if not data.get("filename") and data.get("url"):
-            data["filename"] = data["url"].split("/")[-1]
-        return data
+            parsed = urlparse(data["url"])
+            data["filename"] = unquote(parsed.path.split("/")[-1])
+        return data

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

@@ -1,5 +1,6 @@
 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")
@@ -11,9 +12,9 @@ class ChattyContentMedia(BaseModel):
     def validate_url(cls, v):
         if not v:
             raise ValueError("URL is required")
-        HttpUrl(v)
-        return v
+        encoded = quote(str(v), safe=":/?&=%#")
+        HttpUrl(encoded)
+        return encoded
     
     def get_body_or_caption(self) -> str:
         return self.caption
-

letschatty/models/utils/custom_exceptions/custom_exceptions.py

@@ -5,7 +5,6 @@ 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):
@@ -230,16 +229,4 @@ 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)
-
-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)
+        super().__init__(message, status_code=status_code, **context_data)

letschatty/services/ai_agents/smart_follow_up_context_builder_v2.py

@@ -14,16 +14,13 @@ class SmartFollowUpContextBuilder(ContextBuilder):
 
     @staticmethod
     def check_minimum_time_since_last_message(chat: Chat, follow_up_strategy: FollowUpStrategy,smart_follow_up_state: FlowStateAssignedToChat) -> bool:
-        # 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)
+        expected_interval_minutes = follow_up_strategy.get_interval_for_followup(smart_follow_up_state.consecutive_count)
         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 #{next_followup_number}")
+            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}")
         return True