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

letschatty/services/chatty_assets/asset_service.py

@@ -1,11 +1,22 @@
 from __future__ import annotations
-from typing import TypeVar, Generic, Type, Callable, Protocol, Optional
+from typing import TypeVar, Generic, Type, Callable, Protocol, Optional, ClassVar, TYPE_CHECKING, List
+
+from bson import ObjectId
+from letschatty.models.utils.types import StrObjectId
 from .base_container_with_collection import ChattyAssetCollectionInterface, ChattyAssetContainerWithCollection, CacheConfig
 from ...models.base_models import ChattyAssetModel
 from ...models.base_models.chatty_asset_model import ChattyAssetPreview
 from ...models.data_base.mongo_connection import MongoConnection
 import logging
 import os
+
+if TYPE_CHECKING:
+    from ...models.analytics.events.base import EventType
+    from ...models.company.empresa import EmpresaModel
+    from ...models.execution.execution import ExecutionContext
+    from ...models.company.assets.company_assets import CompanyAssetType
+    from ...models.utils.types.deletion_type import DeletionType
+
 logger = logging.getLogger("AssetService")
 
 # Protocol for assets that specify their preview type
@@ -44,17 +55,75 @@ class AssetCollection(Generic[T, P], ChattyAssetCollectionInterface[T, P]):
             raise ValueError(f"Data must be a dictionary, got {type(data)}: {data}")
         return self._create_instance_method(data)
 
+
 class AssetService(Generic[T, P], ChattyAssetContainerWithCollection[T, P]):
-    """Generic service for handling CRUD operations for any Chatty asset"""
+    """
+    Generic service for handling CRUD operations for any Chatty asset.
+
+    Supports optional automatic event handling for API implementations.
+    Set these class attributes to enable events:
+    - asset_type_enum: CompanyAssetType (e.g., CompanyAssetType.PRODUCTS)
+    - event_type_created: EventType (e.g., EventType.PRODUCT_CREATED)
+    - event_type_updated: EventType (e.g., EventType.PRODUCT_UPDATED)
+    - event_type_deleted: EventType (e.g., EventType.PRODUCT_DELETED)
+    """
+
+    # Optional: Set these in subclasses to enable automatic event handling
+    asset_type_enum: ClassVar[Optional['CompanyAssetType']] = None
+    event_type_created: ClassVar[Optional['EventType']] = None
+    event_type_updated: ClassVar[Optional['EventType']] = None
+    event_type_deleted: ClassVar[Optional['EventType']] = None
+
+    collection: AssetCollection[T, P]  # Type annotation for better type checking
 
     def __init__(self,
-                 collection_name: str,
-                 asset_type: Type[T],
-                 connection: MongoConnection,
-                 create_instance_method: Callable[[dict], T],
-                 preview_type: Optional[Type[P]] = None,
+                 collection: AssetCollection[T, P],
                  cache_config: CacheConfig = CacheConfig.default()):
-        logger.debug(f"AssetService {self.__class__.__name__} initializing for {collection_name}")
+        """
+        Initialize AssetService with a pre-configured collection.
+
+        The item_type and preview_type are automatically extracted from the collection,
+        eliminating redundancy and simplifying the API.
+
+        Args:
+            collection: Pre-configured AssetCollection subclass
+            cache_config: Cache configuration
+        """
+        logger.debug(f"AssetService {self.__class__.__name__} initializing with collection")
+        super().__init__(
+            item_type=collection.type,
+            preview_type=collection.preview_type,
+            collection=collection,
+            cache_config=cache_config,
+        )
+        logger.debug(f"AssetService {self.__class__.__name__} initialized")
+
+    @classmethod
+    def from_config(cls,
+                    collection_name: str,
+                    asset_type: Type[T],
+                    connection: MongoConnection,
+                    create_instance_method: Callable[[dict], T],
+                    preview_type: Optional[Type[P]] = None,
+                    cache_config: CacheConfig = CacheConfig.default()) -> 'AssetService[T, P]':
+        """
+        Create an AssetService using the legacy configuration pattern.
+
+        This class method is provided for backward compatibility.
+        New code should use pre-configured AssetCollection subclasses.
+
+        Args:
+            collection_name: MongoDB collection name
+            asset_type: The asset model type
+            connection: MongoDB connection
+            create_instance_method: Factory method to create asset instances
+            preview_type: Optional preview type
+            cache_config: Cache configuration
+
+        Returns:
+            AssetService instance
+        """
+        logger.debug(f"AssetService creating from config for {collection_name}")
         asset_collection = AssetCollection(
             collection=collection_name,
             asset_type=asset_type,
@@ -62,13 +131,102 @@ class AssetService(Generic[T, P], ChattyAssetContainerWithCollection[T, P]):
             create_instance_method=create_instance_method,
             preview_type=preview_type
         )
-        super().__init__(
-            item_type=asset_type,
-            preview_type=preview_type,
+        return cls(
             collection=asset_collection,
-            cache_config=cache_config,
+            cache_config=cache_config
         )
-        logger.debug(f"AssetService {self.__class__.__name__} initialized for {collection_name}")
+
+    def _should_handle_events(self) -> bool:
+        """Check if this service should handle events automatically"""
+        return (self.asset_type_enum is not None and
+                self.event_type_created is not None and
+                self.event_type_updated is not None and
+                self.event_type_deleted is not None)
+
+    def _queue_event(self, item: T, event_type: 'EventType', execution_context: 'ExecutionContext', company_info: 'EmpresaModel'):
+        """Queue an event for this asset if event handling is enabled"""
+        if not self._should_handle_events() or not self.asset_type_enum:
+            return
+
+        try:
+            from ...services.factories.analytics.events_factory import EventFactory
+            from ...services.events import events_manager
+
+            # Type guard - company_id should exist on ChattyAssetModel
+            if not hasattr(item, 'company_id'):
+                logger.warning(f"Asset {type(item).__name__} missing company_id, skipping event")
+                return
+
+            events = EventFactory.asset_events(
+                company_id=item.company_id,  # type: ignore[attr-defined]
+                executor_id=execution_context.executor.id,
+                asset=item,
+                asset_type=self.asset_type_enum,
+                event_type=event_type,
+                time=execution_context.time,
+                trace_id=execution_context.trace_id,
+                executor_type=execution_context.executor.type,
+                company_info=company_info
+            )
+            events_manager.queue_events(events)
+        except ImportError:
+            # Events not available (microservice context) - skip
+            pass
+
+    # All methods are now async-only for better performance
+    async def insert(self, item: T, execution_context: 'ExecutionContext', company_info: Optional['EmpresaModel'] = None) -> T:
+        """Insert with automatic event handling if configured"""
+        result = await super().insert(item, execution_context)
+        if company_info and self._should_handle_events() and self.event_type_created:
+            self._queue_event(result, self.event_type_created, execution_context, company_info)
+        return result
+
+    async def update(self, id: str, new_item: T, execution_context: 'ExecutionContext', company_info: Optional['EmpresaModel'] = None) -> T:
+        """Update with automatic event handling if configured"""
+        result = await super().update(id, new_item, execution_context)
+        if company_info and self._should_handle_events() and self.event_type_updated:
+            self._queue_event(result, self.event_type_updated, execution_context, company_info)
+        return result
+
+    async def delete(self, id: str, execution_context: 'ExecutionContext', company_info: Optional['EmpresaModel'] = None, deletion_type: Optional['DeletionType'] = None) -> T:
+        """Delete with automatic event handling if configured"""
+        from ...models.utils.types.deletion_type import DeletionType as DT
+        result = await super().delete(id, execution_context, deletion_type or DT.LOGICAL)
+        if company_info and self._should_handle_events() and self.event_type_deleted:
+            self._queue_event(result, self.event_type_deleted, execution_context, company_info)
+        return result
+
+    async def restore(self, id: str, execution_context: 'ExecutionContext', company_info: Optional['EmpresaModel'] = None) -> T:
+        """Restore with automatic event handling if configured"""
+        result = await super().restore(id, execution_context)
+        if company_info and self._should_handle_events() and self.event_type_updated:
+            self._queue_event(result, self.event_type_updated, execution_context, company_info)
+        return result
+
+    # Generic convenience methods
+    async def create_asset(self, data: dict, execution_context: 'ExecutionContext', company_info: 'EmpresaModel') -> T:
+        """
+        Generic create method - creates instance from dict and inserts with events.
+        Can be called as create_asset or aliased to create_product/create_tag/etc.
+        """
+        data["company_id"] = execution_context.company_id
+        item = self.collection.create_instance(data)
+        return await self.insert(item, execution_context, company_info)
+
+    async def update_asset(self, id: str, data: dict, execution_context: 'ExecutionContext', company_info: 'EmpresaModel') -> T:
+        """
+        Generic update method - creates instance from dict and updates with events.
+        Can be called as update_asset or aliased to update_product/update_tag/etc.
+        """
+        new_item = self.collection.create_instance(data)
+        return await self.update(id, new_item, execution_context, company_info)
+
+    async def delete_asset(self, id: str, execution_context: 'ExecutionContext', company_info: 'EmpresaModel') -> T:
+        """
+        Generic delete method - deletes with events.
+        Can be called as delete_asset or aliased to delete_product/delete_tag/etc.
+        """
+        return await self.delete(id, execution_context, company_info)
 
     def get_preview_type(self) -> Type[P]:
         """Get the preview type from the asset class if it has one"""
@@ -81,3 +239,22 @@ class AssetService(Generic[T, P], ChattyAssetContainerWithCollection[T, P]):
         preview_type = self.get_preview_type()
         return super().get_preview_by_id(id, company_id, preview_type)
 
+    # Additional async read methods (passthrough to base class)
+    async def get_by_id(self, id: str) -> T:
+        """Get by ID"""
+        return await super().get_by_id(id)
+
+    async def get_all(self, company_id: str) -> List[T]:
+        """Get all for company"""
+        return await super().get_all(company_id)
+
+    async def get_by_query(self, query: dict, company_id: Optional[str]) -> List[T]:
+        """Get by query"""
+        return await super().get_by_query(query, company_id)
+
+    async def get_item_dumped(self, id: str) -> dict:
+        """Get item by ID and return as JSON serialized dict for frontend"""
+        from ...models.utils.types.serializer_type import SerializerType
+        item = await self.get_by_id(id)
+        return item.model_dump_json(serializer=SerializerType.FRONTEND)
+

letschatty/services/chatty_assets/assets_collections.py

@@ -0,0 +1,137 @@
+"""
+Read-only Assets Collections Container
+
+This module provides a singleton container class that gives microservices
+read-only access to asset data using pre-configured AssetCollection subclasses.
+Perfect for services that only need to read asset data without CRUD operations.
+"""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any
+import logging
+
+# Import base components
+from ...models.data_base.mongo_connection import MongoConnection
+from ...models.base_models.singleton import SingletonMeta
+
+# Import pre-configured collection subclasses
+from .collections import (
+    ProductCollection,
+    TagCollection,
+    UserCollection,
+    ChatCollection,
+    SourceCollection,
+    FlowCollection,
+    SaleCollection,
+    ContactPointCollection,
+    AiAgentCollection,
+    FilterCriteriaCollection,
+    AiComponentCollection
+)
+
+# Import asset models for type hints
+from ...models.company.assets.product import Product
+from ...models.company.assets.tag import Tag
+from ...models.company.assets.users.user import User
+from ...models.chat.chat import Chat
+from ...models.analytics.sources import SourceBase
+from ...models.company.assets.flow import FlowPreview
+from ...models.company.assets.sale import Sale
+from ...models.company.assets.contact_point import ContactPoint
+from ...models.company.assets.ai_agents_v2.chatty_ai_agent import ChattyAIAgent
+from ...models.company.assets.filter_criteria import FilterCriteria
+
+if TYPE_CHECKING:
+    pass
+
+logger = logging.getLogger("AssetsCollections")
+
+
+class AssetsCollections(metaclass=SingletonMeta):
+    """
+    Read-only singleton container for accessing asset collections across microservices.
+
+    This class provides simple read access to various asset types without the overhead
+    of the full AssetService (no caching, no events, no write operations).
+
+    Usage:
+        assets = AssetsCollections(connection)
+        product = assets.get_product_by_id(product_id)
+        tag = assets.get_tag_by_id(tag_id)
+    """
+
+    def __init__(self, connection: MongoConnection):
+        """
+        Initialize all asset collections using pre-configured collection subclasses.
+
+        Args:
+            connection: MongoConnection instance to use for database access
+        """
+        logger.debug("Initializing AssetsCollections")
+
+        # Initialize all collections using pre-configured subclasses
+        # Each collection subclass already knows its collection name, asset type,
+        # preview type, and create_instance_method
+        self.products = ProductCollection(connection)
+        self.tags = TagCollection(connection)
+        self.users = UserCollection(connection)
+        self.chats = ChatCollection(connection)
+        self.sources = SourceCollection(connection)
+        self.flows = FlowCollection(connection)
+        self.sales = SaleCollection(connection)
+        self.contact_points = ContactPointCollection(connection)
+        self.ai_agents = AiAgentCollection(connection)
+        self.filter_criterias = FilterCriteriaCollection(connection)
+        self.ai_components = AiComponentCollection(connection)
+
+        logger.debug("AssetsCollections initialized successfully")
+
+    # Convenience getter methods for easy access
+
+    async def get_product_by_id(self, id: str) -> Product:
+        """Get a product by ID."""
+        return await self.products.get_by_id(id)
+
+    async def get_tag_by_id(self, id: str) -> Tag:
+        """Get a tag by ID."""
+        return await self.tags.get_by_id(id)
+
+    async def get_user_by_id(self, id: str) -> User:
+        """Get a user by ID."""
+        return await self.users.get_by_id(id)
+
+    async def get_chat_by_id(self, id: str) -> Chat:
+        """Get a chat by ID."""
+        return await self.chats.get_by_id(id)
+
+    async def get_source_by_id(self, id: str) -> SourceBase:
+        """Get a source by ID."""
+        return await self.sources.get_by_id(id)
+
+    async def get_flow_by_id(self, id: str) -> FlowPreview:
+        """Get a flow by ID."""
+        return await self.flows.get_by_id(id)
+
+    async def get_sale_by_id(self, id: str) -> Sale:
+        """Get a sale by ID."""
+        return await self.sales.get_by_id(id)
+
+    async def get_contact_point_by_id(self, id: str) -> ContactPoint:
+        """Get a contact point by ID."""
+        return await self.contact_points.get_by_id(id)
+
+    async def get_ai_agent_by_id(self, id: str) -> ChattyAIAgent:
+        """Get an AI agent by ID."""
+        return await self.ai_agents.get_by_id(id)
+
+    async   def get_filter_criteria_by_id(self, id: str) -> FilterCriteria:
+        """Get a filter criteria by ID."""
+        return await self.filter_criterias.get_by_id(id)
+
+    async def get_filter_criterias_by_ids(self, ids: list[str]) -> list[FilterCriteria]:
+        """Get multiple filter criterias by their IDs in a single query."""
+        return await self.filter_criterias.get_by_ids(ids=ids)
+
+    async def get_ai_components_by_ids(self, ids: list[str]) -> list[Any]:
+        """Get multiple AI components by their IDs in a single query."""
+        return await self.ai_components.get_by_ids(ids=ids)
+

letschatty/services/chatty_assets/base_container.py

@@ -123,8 +123,9 @@ class ChattyAssetBaseContainer(Generic[T, P], ABC):
         else:
             return list(self.items.values())
 
-    def get_all_dict_id_item(self, company_id:Optional[StrObjectId]) -> Dict[StrObjectId, T]:
-        return {item.id: item for item in self.get_all(company_id)}
+    async def get_all_dict_id_item(self, company_id:Optional[StrObjectId]) -> Dict[StrObjectId, T]:
+        items = await self.get_all(company_id)
+        return {item.id: item for item in items}
 
     def get_all_previews(self, company_id:Optional[StrObjectId]) -> List[P]:
         logger.debug(f"Getting all previews for {self.__class__.__name__}")

letschatty/services/chatty_assets/base_container_with_collection.py

@@ -64,7 +64,8 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
         self.update_previews_thread()
         self.load_from_db_thread(company_id=None)
 
-    def insert(self, item: T, execution_context: ExecutionContext) -> T:
+    # All methods are now async-only for better performance
+    async def insert(self, item: T, execution_context: ExecutionContext) -> T:
         """
         Add an item to the container and insert it into the database collection.
 
@@ -77,12 +78,12 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
         """
         logger.debug(f"{self.__class__.__name__} inserting item {item}")
         inserted_item = super().insert(item)
-        self.collection.insert(inserted_item)
+        await self.collection.insert(inserted_item)
         execution_context.set_event_time(inserted_item.created_at)
         self.update_previews_thread()
         return inserted_item
 
-    def update(self, id: str, new_item: T, execution_context: ExecutionContext) -> T:
+    async def update(self, id: str, new_item: T, execution_context: ExecutionContext) -> T:
         """
         Update an item in the container and in the database collection.
 
@@ -105,18 +106,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}")
-            self.collection.update(updated_item)
+            await 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 = self.collection.get_by_id(id)
+            outdated_item = await self.collection.get_by_id(id)
             if outdated_item:
                 updated_item = outdated_item.update(new_item)
                 self.items[id] = updated_item
-                self.collection.update(updated_item)
+                await self.collection.update(updated_item)
                 execution_context.set_event_time(updated_item.updated_at)
                 self.update_previews_thread()
                 return updated_item
@@ -125,7 +126,7 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
                 f"Item with id {id} not found in {self.__class__.__name__} nor in collection DB"
             )
 
-    def delete(self, id: str, execution_context: ExecutionContext,deletion_type : DeletionType = DeletionType.LOGICAL) -> T:
+    async def delete(self, id: str, execution_context: ExecutionContext,deletion_type : DeletionType = DeletionType.LOGICAL) -> T:
         """
         Delete an item from the container and the collection.
 
@@ -142,16 +143,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")))
-            self.collection.delete(id, deletion_type)
+            await self.collection.delete(id, deletion_type)
             return deleted_item
         except NotFoundError as e:
-            self.collection.delete(id, deletion_type)
+            await self.collection.delete(id, deletion_type)
             self.delete_preview(id)
             self.update_previews_thread()
             execution_context.set_event_time(datetime.now(ZoneInfo("UTC")))
-            return self.collection.get_by_id(id)
+            return await self.collection.get_by_id(id)
 
-    def get_by_id(self, id: str) -> T:
+    async def get_by_id(self, id: str) -> T:
         """
         Get an item from the container.
 
@@ -174,7 +175,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 = self.collection.get_by_id(id)
+            item = await self.collection.get_by_id(id)
             if item:
                 if item.deleted_at is not None:
                     return item
@@ -239,7 +240,7 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
             logger.debug(f"Clearing previews cache of {self.__class__.__name__}")
             self.set_preview_items([])
 
-    def get_all(self, company_id: Optional[StrObjectId]) -> List[T]:
+    async 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)
@@ -247,7 +248,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 = self.collection.get_docs(query=query, company_id=company_id)
+        collection_items = await 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)
 
@@ -261,6 +262,8 @@ 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()
 
@@ -275,13 +278,13 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
         self.set_preview_items(collection_items)
         return collection_items
 
-    def get_by_query(self, query: dict, company_id: Optional[StrObjectId]) -> List[T]:
+    async 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 self.collection.get_docs(query=query, company_id=company_id)
+        return await self.collection.get_docs(query=query, company_id=company_id)
 
-    def get_deleted(self, company_id: Optional[StrObjectId]) -> List[T]:
+    async def get_deleted(self, company_id: Optional[StrObjectId]) -> List[T]:
         logger.debug(f"{self.__class__.__name__} getting deleted items from collection")
-        return self.collection.get_docs(query={"deleted_at": {"$ne": None}}, company_id=company_id)
+        return await 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"""
@@ -292,21 +295,27 @@ 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."""
+        """Pass company_id=None to load all items from the database. Uses sync client for background loading."""
         logger.debug(f"{self.__class__.__name__} loading items from collection")
-        # 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:
+        # 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:
         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 = self.collection.get_by_id(id)
+        restored_item = await 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
-        self.collection.update(restored_item)
-        return restored_item
+        await self.collection.update(restored_item)
+        return restored_item

letschatty/services/chatty_assets/collections/__init__.py

@@ -0,0 +1,38 @@
+"""
+Asset Collection Subclasses
+
+This module provides pre-configured AssetCollection subclasses for each asset type.
+These ensure consistency between the API and microservices by defining the collection
+configuration (collection name, asset type, preview type, create_instance_method) once.
+"""
+
+from .product_collection import ProductCollection
+from .tag_collection import TagCollection
+from .user_collection import UserCollection
+from .chat_collection import ChatCollection
+from .source_collection import SourceCollection
+from .flow_collection import FlowCollection
+from .sale_collection import SaleCollection
+from .contact_point_collection import ContactPointCollection
+from .ai_agent_collection import AiAgentCollection
+from .fast_answer_collection import FastAnswerCollection
+from .topic_collection import TopicCollection
+from .filter_criteria_collection import FilterCriteriaCollection
+from .ai_component_collection import AiComponentCollection
+
+__all__ = [
+    'ProductCollection',
+    'TagCollection',
+    'UserCollection',
+    'ChatCollection',
+    'SourceCollection',
+    'FlowCollection',
+    'SaleCollection',
+    'ContactPointCollection',
+    'AiAgentCollection',
+    'FastAnswerCollection',
+    'TopicCollection',
+    'FilterCriteriaCollection',
+    'AiComponentCollection',
+]
+

letschatty/services/chatty_assets/collections/ai_agent_collection.py

@@ -0,0 +1,19 @@
+"""AI Agent Collection - Pre-configured AssetCollection for AI Agents"""
+
+from ..asset_service import AssetCollection
+from ....models.company.assets.ai_agents_v2.chatty_ai_agent import ChattyAIAgent, ChattyAIAgentPreview
+from ....models.data_base.mongo_connection import MongoConnection
+
+
+class AiAgentCollection(AssetCollection[ChattyAIAgent, ChattyAIAgentPreview]):
+    """Pre-configured collection for AI Agent assets"""
+
+    def __init__(self, connection: MongoConnection):
+        super().__init__(
+            collection="ai_agents",
+            asset_type=ChattyAIAgent,
+            connection=connection,
+            create_instance_method=ChattyAIAgent.default_create_instance_method,
+            preview_type=ChattyAIAgentPreview
+        )
+

letschatty/services/chatty_assets/collections/ai_agent_in_chat_collection.py

@@ -0,0 +1,32 @@
+"""AI Agent In Chat Collection - Pre-configured AssetCollection for AI Agent state in chats"""
+
+from ..asset_service import AssetCollection
+from ....models.company.assets.ai_agents_v2.chatty_ai_agent_in_chat import ChattyAIAgentInChat
+from ....models.data_base.mongo_connection import MongoConnection
+from typing import Optional
+
+
+class AIAgentInChatCollection(AssetCollection[ChattyAIAgentInChat, ChattyAIAgentInChat]):
+    """
+    Pre-configured collection for AI Agent In Chat state.
+
+    This is a standalone collection (not embedded in Chat) that allows Lambda to
+    manage AI agent state independently without loading entire chat documents.
+    """
+
+    def __init__(self, connection: MongoConnection):
+        super().__init__(
+            collection="chatty_ai_agents_in_chat",
+            asset_type=ChattyAIAgentInChat,
+            connection=connection,
+            create_instance_method=lambda doc: ChattyAIAgentInChat(**doc),
+            preview_type=ChattyAIAgentInChat  # No separate preview type needed
+        )
+
+    async def get_by_chat_id(self, chat_id: str) -> Optional[ChattyAIAgentInChat]:
+        """Get AI agent state by chat ID, or None if not found"""
+        doc = await self.async_collection.find_one({"chat_id": chat_id, "deleted_at": None})
+        if not doc:
+            return None
+        return self.create_instance(doc)
+

letschatty/services/chatty_assets/collections/ai_component_collection.py

@@ -0,0 +1,21 @@
+"""AI Component Collection - Pre-configured AssetCollection for AI Components"""
+
+from typing import Any
+from ..asset_service import AssetCollection
+from ....models.base_models.ai_agent_component import AiAgentComponent, AiAgentComponentPreview
+from ....models.data_base.mongo_connection import MongoConnection
+from ....services.ai_components_service import AiComponentsService
+
+
+class AiComponentCollection(AssetCollection[AiAgentComponent, AiAgentComponentPreview]):
+    """Pre-configured collection for AI Component assets"""
+
+    def __init__(self, connection: MongoConnection):
+        super().__init__(
+            collection="ai_components",
+            asset_type=AiAgentComponent,
+            connection=connection,
+            create_instance_method=AiComponentsService.instantiate_component,
+            preview_type=AiAgentComponentPreview
+        )
+