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

letschatty/models/ai_microservices/expected_output.py

@@ -27,6 +27,20 @@ class ExpectedOutputSmartTag(BaseModel):
     chain_of_thought: ChainOfThoughtInChatRequest = Field(
         description="REQUIRED: Your reasoning process and response decision explanation"
     )
+    # Unsubscribe intent detection (for launch agents)
+    unsubscribe_intent: bool = Field(
+        default=False,
+        description="True if user expressed intent to unsubscribe from communications (e.g., 'no more messages', 'unsubscribe', 'stop', 'rechazar mensajes')"
+    )
+    # Acceptance criteria evaluation (for agents with data collection + acceptance_criteria)
+    acceptance_criteria_met: Optional[bool] = Field(
+        default=None,
+        description="True if user meets acceptance criteria, False if not, None if cannot be determined yet or no criteria configured"
+    )
+    acceptance_criteria_reason: Optional[str] = Field(
+        default=None,
+        description="Reason explaining why acceptance criteria is met or not met"
+    )
 
     @staticmethod
     def get_json_schema() -> dict:
@@ -100,9 +114,21 @@ class ExpectedOutputSmartTag(BaseModel):
                     },
                     "required": ["trigger", "trigger_id", "chatty_ai_agent_id", "chain_of_thought", "title"],
                     "additionalProperties": False
+                },
+                "unsubscribe_intent": {
+                    "type": "boolean",
+                    "description": "True if user expressed intent to unsubscribe from communications (e.g., 'no more messages', 'unsubscribe', 'stop', 'rechazar mensajes')"
+                },
+                "acceptance_criteria_met": {
+                    "anyOf": [{"type": "boolean"}, {"type": "null"}],
+                    "description": "True if user meets acceptance criteria, False if not, null if cannot be determined yet"
+                },
+                "acceptance_criteria_reason": {
+                    "anyOf": [{"type": "string"}, {"type": "null"}],
+                    "description": "Reason explaining why acceptance criteria is met or not met"
                 }
             },
-            "required": ["automation", "conversation_topics", "data_collection", "chain_of_thought"],
+            "required": ["automation", "conversation_topics", "data_collection", "chain_of_thought", "unsubscribe_intent", "acceptance_criteria_met", "acceptance_criteria_reason"],
             "additionalProperties": False
         }
 
@@ -143,6 +169,12 @@ class ExpectedOutputIncomingMessage(BaseModel):
     action: IncomingMessageDecisionAction
     messages: List[str] = Field(description="Array of message strings to send to the customer. Required for send/suggest actions, optional for escalate action, empty array for skip/remove actions.")
     chain_of_thought: ChainOfThoughtInChatRequest = Field(description="REQUIRED: Your reasoning process and response decision explanation")
+    confidence: Optional[int] = Field(
+        default=None,
+        ge=0,
+        le=100,
+        description="Confidence level 0-100"
+    )
 
     def to_incoming_message_decision_output(self) -> IncomingMessageAIDecision:
         messages_drafts = [
@@ -161,3 +193,5 @@ class ExpectedOutputIncomingMessage(BaseModel):
         return incoming_decision
 
 
+class ExpectedOutputSmartFollowUp(BaseModel):
+    action: Optional[str] = None

letschatty/models/ai_microservices/lambda_events.py

@@ -5,8 +5,9 @@ from typing import Dict, Any, List, Optional
 from letschatty.models.base_models.ai_agent_component import AiAgentComponentType
 from letschatty.models.utils.types.identifier import StrObjectId
 from .lambda_invokation_types import InvokationType, LambdaAiEvent
-from .expected_output import ExpectedOutputIncomingMessage, ExpectedOutputSmartTag, ExpectedOutputQualityTest, IncomingMessageAIDecision
+from .expected_output import ExpectedOutputIncomingMessage, ExpectedOutputSmartTag, ExpectedOutputQualityTest, ExpectedOutputSmartFollowUp, IncomingMessageAIDecision
 from ...models.company.assets.ai_agents_v2.ai_agents_decision_output import IncomingMessageDecisionAction
+from ...models.company.assets.ai_agents_v2.chatty_ai_agent_in_chat import HumanInterventionReason
 
 class SmartTaggingCallbackMetadata(BaseModel):
     chat_id: StrObjectId
@@ -60,10 +61,23 @@ class SmartTaggingCallbackEvent(LambdaAiEvent):
     callback_metadata: SmartTaggingCallbackMetadata
 
     @model_validator(mode="before")
-    def validate_data(cls, data):
-        if isinstance(data, dict) and "data" in data and "chain_of_thought" in data["data"]:
-                data["data"]["chain_of_thought"]["chatty_ai_agent_id"] = "000000000000000000000000"
-        return data
+    def normalize_data(cls, values):
+        if not isinstance(values, dict):
+            return values
+
+        data = values.get("data")
+        if isinstance(data, str):
+            import json
+            try:
+                data = json.loads(data)
+                values["data"] = data
+            except (json.JSONDecodeError, TypeError):
+                return values
+
+        if isinstance(data, dict) and "chain_of_thought" in data:
+            data["chain_of_thought"]["chatty_ai_agent_id"] = "000000000000000000000000"
+
+        return values
 
 class ChatData(BaseModel):
     chat_id: StrObjectId
@@ -77,6 +91,11 @@ class FollowUpEvent(LambdaAiEvent):
     type: InvokationType = InvokationType.FOLLOW_UP
     data: ChatData
 
+
+class SmartFollowUpDecisionOutputEvent(LambdaAiEvent):
+    type: InvokationType = InvokationType.FOLLOW_UP
+    data: ExpectedOutputSmartFollowUp
+
 class QualityTestEventData(BaseModel):
     chat_example_id: StrObjectId
     company_id: StrObjectId
@@ -333,3 +352,45 @@ class UnescalateAIAgentInChatEvent(LambdaAiEvent):
     """
     type: InvokationType = InvokationType.UNESCALATE_AI_AGENT_IN_CHAT
     data: UnescalateAIAgentInChatEventData
+
+
+# Launch Events
+
+class LaunchCommunicationEventData(BaseModel):
+    """Data for sending a scheduled launch communication"""
+    chat_ids: List[StrObjectId] = Field(description="Batch of chat IDs to send communication to")
+    company_id: StrObjectId
+    launch_id: StrObjectId
+    communication_id: str = Field(description="ID of the communication within the launch")
+    communication_type: str = Field(description="Type: pre_launch, post_attended, post_missed, welcome_kit")
+    lambda_callback_url: str = Field(description="URL for Lambda to call back after N8N processing")
+
+
+class LaunchCommunicationEvent(LambdaAiEvent):
+    """
+    Event to send a scheduled launch communication.
+
+    Triggered by Copilot when delta_minutes is reached. Lambda processes
+    the batch of chats, building context for each and sending to N8N
+    for AI adaptation (or sending literal messages directly).
+    """
+    type: InvokationType = InvokationType.LAUNCH_COMMUNICATION
+    data: LaunchCommunicationEventData
+
+
+class LaunchWelcomeKitEventData(BaseModel):
+    """Data for sending a welcome kit with AI adaptation"""
+    chat_id: StrObjectId
+    company_id: StrObjectId
+    launch_id: StrObjectId
+
+
+class LaunchWelcomeKitEvent(LambdaAiEvent):
+    """
+    Event to send a welcome kit with AI adaptation.
+
+    Triggered when a user subscribes to a launch and the welcome kit
+    requires AI adaptation. Lambda builds context and sends to N8N.
+    """
+    type: InvokationType = InvokationType.LAUNCH_WELCOME_KIT
+    data: LaunchWelcomeKitEventData

letschatty/models/ai_microservices/lambda_invokation_types.py

@@ -30,6 +30,9 @@ class InvokationType(StrEnum):
     UPDATE_AI_AGENT_MODE_IN_CHAT = "update_ai_agent_mode_in_chat"
     ESCALATE_AI_AGENT_IN_CHAT = "escalate_ai_agent_in_chat"
     UNESCALATE_AI_AGENT_IN_CHAT = "unescalate_ai_agent_in_chat"
+    # Launch events
+    LAUNCH_COMMUNICATION = "launch_communication"
+    LAUNCH_WELCOME_KIT = "launch_welcome_kit"
 
 class LambdaAiEvent(BaseModel):
     type: InvokationType

letschatty/models/analytics/events/__init__.py

@@ -4,7 +4,7 @@ from .chat_based_events.business_area import ChatBusinessAreaEvent, BusinessArea
 from .chat_based_events.workflow import WorkflowEvent, WorkflowEventData
 from .chat_based_events.chat_status import ChatStatusEvent, ChatStatusEventData, ChatStatusModification, ChatCreatedFrom
 from .chat_based_events.chat_funnel import ChatFunnelEvent, FunnelEventData
-from ...company.CRM.funnel import ClientFunnel, StageTransition
+from ...company.CRM.funnel import ChatFunnel, StageTransition, ActiveFunnel
 from .company_based_events.user_events import UserEvent, UserEventData
 from .chat_based_events.quality_scoring import QualityScoringEvent
 from .chat_based_events.message import MessageEvent, MessageData

letschatty/models/analytics/events/chat_based_events/chat_funnel.py

@@ -4,37 +4,93 @@ from ..base import Event
 from ..event_types import EventType
 from .chat_based_event import CustomerEventData
 from ....utils.types.identifier import StrObjectId
-from ....company.CRM.funnel import ClientFunnel, StageTransition
+from ....company.CRM.funnel import StageTransition
 import json
 
+
 class FunnelEventData(CustomerEventData):
-    funnel_id: StrObjectId
-    funnel_stage_transition: StageTransition
-    time_in_funnel_seconds: Optional[int] = None
+    """
+    Event data for chat funnel events.
+    
+    Fields required per event type:
+    - STARTED: funnel_id, chat_funnel_id, stage_transition
+    - STAGE_CHANGED: funnel_id, chat_funnel_id, stage_transition (with time_in_previous_stage_seconds)
+    - COMPLETED: funnel_id, chat_funnel_id, time_in_funnel_seconds, time_in_last_stage_seconds
+    - ABANDONED: funnel_id, chat_funnel_id, time_in_funnel_seconds, time_in_last_stage_seconds
+    """
+    funnel_id: StrObjectId = Field(description="The funnel the chat is in")
+    chat_funnel_id: StrObjectId = Field(description="Reference to the ChatFunnel record")
+    
+    # For STARTED and STAGE_CHANGED events
+    stage_transition: Optional[StageTransition] = Field(
+        default=None,
+        description="The stage transition details (for STARTED and STAGE_CHANGED)"
+    )
+    
+    # For COMPLETED and ABANDONED events
+    time_in_funnel_seconds: Optional[int] = Field(
+        default=None,
+        description="Total time spent in the funnel (for COMPLETED and ABANDONED)"
+    )
+    time_in_last_stage_seconds: Optional[int] = Field(
+        default=None,
+        description="Time spent in the last stage before completion/abandonment"
+    )
+
 
 class ChatFunnelEvent(Event):
-    """Event for tracking chat funnel stage transitions"""
+    """
+    Event for tracking chat funnel lifecycle.
+    
+    Events:
+    - CHAT_FUNNEL_STARTED: Chat entered a funnel
+    - CHAT_FUNNEL_STAGE_CHANGED: Chat moved between stages
+    - CHAT_FUNNEL_COMPLETED: Chat completed the funnel
+    - CHAT_FUNNEL_ABANDONED: Chat abandoned the funnel
+    """
     data: FunnelEventData
 
-    # Define valid event types for this event class
     VALID_TYPES: ClassVar[set] = {
-        EventType.CHAT_FUNNEL_UPDATED,
         EventType.CHAT_FUNNEL_STARTED,
+        EventType.CHAT_FUNNEL_STAGE_CHANGED,
         EventType.CHAT_FUNNEL_COMPLETED,
         EventType.CHAT_FUNNEL_ABANDONED
     }
 
-
     @field_validator('data')
     def validate_data_fields(cls, v: FunnelEventData, info: ValidationInfo):
         """Validate that appropriate fields are set based on event type"""
-        if info.data.get('type') == EventType.CHAT_FUNNEL_UPDATED and v.time_in_funnel_seconds is None:
-            raise ValueError("time_in_funnel_seconds must be set for CHAT_FUNNEL_UPDATED events")
-        if info.data.get('type') == EventType.CHAT_FUNNEL_UPDATED and v.funnel_stage_transition.time_in_previous_stage_seconds is None:
-            raise ValueError("time_in_previous_stage_seconds must be set for CHAT_FUNNEL_UPDATED events")
+        event_type = info.data.get('type')
+        
+        # STARTED: requires stage_transition
+        if event_type == EventType.CHAT_FUNNEL_STARTED:
+            if v.stage_transition is None:
+                raise ValueError("stage_transition must be set for CHAT_FUNNEL_STARTED events")
+        
+        # STAGE_CHANGED: requires stage_transition with time_in_previous_stage_seconds
+        elif event_type == EventType.CHAT_FUNNEL_STAGE_CHANGED:
+            if v.stage_transition is None:
+                raise ValueError("stage_transition must be set for CHAT_FUNNEL_STAGE_CHANGED events")
+            if v.stage_transition.time_in_previous_stage_seconds is None:
+                raise ValueError("time_in_previous_stage_seconds must be set in stage_transition for CHAT_FUNNEL_STAGE_CHANGED events")
+        
+        # COMPLETED: requires time metrics
+        elif event_type == EventType.CHAT_FUNNEL_COMPLETED:
+            if v.time_in_funnel_seconds is None:
+                raise ValueError("time_in_funnel_seconds must be set for CHAT_FUNNEL_COMPLETED events")
+            if v.time_in_last_stage_seconds is None:
+                raise ValueError("time_in_last_stage_seconds must be set for CHAT_FUNNEL_COMPLETED events")
+        
+        # ABANDONED: requires time metrics
+        elif event_type == EventType.CHAT_FUNNEL_ABANDONED:
+            if v.time_in_funnel_seconds is None:
+                raise ValueError("time_in_funnel_seconds must be set for CHAT_FUNNEL_ABANDONED events")
+            if v.time_in_last_stage_seconds is None:
+                raise ValueError("time_in_last_stage_seconds must be set for CHAT_FUNNEL_ABANDONED events")
+        
         return v
 
     def model_dump_json(self, *args, **kwargs):
         dump = json.loads(super().model_dump_json(*args, **kwargs))
         dump['data'] = self.data.model_dump_json()
-        return dump
+        return dump

letschatty/models/analytics/events/company_based_events/asset_events.py

@@ -58,6 +58,9 @@ class AssetEvent(Event):
         EventType.FUNNEL_STAGE_CREATED,
         EventType.FUNNEL_STAGE_UPDATED,
         EventType.FUNNEL_STAGE_DELETED,
+        EventType.FUNNEL_MEMBER_ADDED,
+        EventType.FUNNEL_MEMBER_UPDATED,
+        EventType.FUNNEL_MEMBER_REMOVED,
         EventType.WORKFLOW_CREATED,
         EventType.WORKFLOW_UPDATED,
         EventType.WORKFLOW_DELETED,
@@ -70,6 +73,9 @@ class AssetEvent(Event):
         EventType.FILTER_CRITERIA_CREATED,
         EventType.FILTER_CRITERIA_UPDATED,
         EventType.FILTER_CRITERIA_DELETED,
+        EventType.FORM_FIELD_CREATED,
+        EventType.FORM_FIELD_UPDATED,
+        EventType.FORM_FIELD_DELETED,
         EventType.COMPANY_CREATED,
         EventType.COMPANY_UPDATED,
         EventType.COMPANY_DELETED
@@ -77,8 +83,9 @@ class AssetEvent(Event):
 
     @model_validator(mode='after')
     def validate_data_fields(self):
-        if "deleted" not in self.type.value and not self.data.asset:
-            raise ValueError("asset must be set for all events except DELETED")
+        # Asset is not required for deleted/removed events
+        if "deleted" not in self.type.value and "removed" not in self.type.value and not self.data.asset:
+            raise ValueError("asset must be set for all events except DELETED/REMOVED")
         return self
 
     def model_dump_json(self, *args, **kwargs):

letschatty/models/analytics/events/event_type_to_classes.py

@@ -41,10 +41,9 @@ EVENT_TO_TYPE_CLASSES = {
     #CONTINUOUS CONVERSATION
     EventType.CONTINUOUS_CONVERSATION_CREATED : ContinuousConversationEvent,
     EventType.CONTINUOUS_CONVERSATION_UPDATED : ContinuousConversationEvent,
-    #FUNNEL STAGES
-    # Funnel-level events
+    #CHAT FUNNEL EVENTS
     EventType.CHAT_FUNNEL_STARTED : ChatFunnelEvent,
-    EventType.CHAT_FUNNEL_UPDATED : ChatFunnelEvent,
+    EventType.CHAT_FUNNEL_STAGE_CHANGED : ChatFunnelEvent,
     EventType.CHAT_FUNNEL_COMPLETED : ChatFunnelEvent,
     EventType.CHAT_FUNNEL_ABANDONED : ChatFunnelEvent,
 
@@ -86,6 +85,10 @@ EVENT_TO_TYPE_CLASSES = {
     EventType.WORKFLOW_CREATED : AssetEvent,
     EventType.WORKFLOW_UPDATED : AssetEvent,
     EventType.WORKFLOW_DELETED : AssetEvent,
+    #FORM FIELDS
+    EventType.FORM_FIELD_CREATED : AssetEvent,
+    EventType.FORM_FIELD_UPDATED : AssetEvent,
+    EventType.FORM_FIELD_DELETED : AssetEvent,
     #AGENTS
     EventType.USER_CREATED : UserEvent,
     EventType.USER_UPDATED : UserEvent,

letschatty/models/analytics/events/event_types.py

@@ -42,10 +42,9 @@ class EventType(StrEnum):
     #CONTINUOUS CONVERSATION
     CONTINUOUS_CONVERSATION_CREATED = "chat.continuous_conversation.created"
     CONTINUOUS_CONVERSATION_UPDATED = "chat.continuous_conversation.updated"
-    #FUNNEL STAGES
-    # Funnel-level events
-    CHAT_FUNNEL_STARTED = "chat.funnel.started"  # New
-    CHAT_FUNNEL_UPDATED = "chat.funnel.updated"
+    #CHAT FUNNEL EVENTS
+    CHAT_FUNNEL_STARTED = "chat.funnel.started"
+    CHAT_FUNNEL_STAGE_CHANGED = "chat.funnel.stage_changed"
     CHAT_FUNNEL_COMPLETED = "chat.funnel.completed"
     CHAT_FUNNEL_ABANDONED = "chat.funnel.abandoned"
 
@@ -84,13 +83,18 @@ class EventType(StrEnum):
     FAST_ANSWER_CREATED = "company.fast_answer.created"
     FAST_ANSWER_UPDATED = "company.fast_answer.updated"
     FAST_ANSWER_DELETED = "company.fast_answer.deleted"
-    #FUNNEL STAGES
+    #FUNNELS
     FUNNEL_CREATED = "company.funnel.created"
     FUNNEL_UPDATED = "company.funnel.updated"
     FUNNEL_DELETED = "company.funnel.deleted"
+    #FUNNEL STAGES
     FUNNEL_STAGE_CREATED = "company.funnel_stage.created"
     FUNNEL_STAGE_UPDATED = "company.funnel_stage.updated"
     FUNNEL_STAGE_DELETED = "company.funnel_stage.deleted"
+    #FUNNEL MEMBERS
+    FUNNEL_MEMBER_ADDED = "company.funnel_member.added"
+    FUNNEL_MEMBER_UPDATED = "company.funnel_member.updated"
+    FUNNEL_MEMBER_REMOVED = "company.funnel_member.removed"
     #BUSINESS AREA
     BUSINESS_AREA_CREATED = "company.business_area.created"
     BUSINESS_AREA_UPDATED = "company.business_area.updated"
@@ -118,3 +122,7 @@ class EventType(StrEnum):
     FILTER_CRITERIA_CREATED = "company.filter_criteria.created"
     FILTER_CRITERIA_UPDATED = "company.filter_criteria.updated"
     FILTER_CRITERIA_DELETED = "company.filter_criteria.deleted"
+    #FORM FIELDS
+    FORM_FIELD_CREATED = "company.form_field.created"
+    FORM_FIELD_UPDATED = "company.form_field.updated"
+    FORM_FIELD_DELETED = "company.form_field.deleted"

letschatty/models/chat/chat.py

@@ -19,6 +19,7 @@ from ..utils.custom_exceptions.custom_exceptions import MissingAIAgentForSmartFo
 from .time_left import TimeLeft
 from ..company.conversation_topic import TopicTimelineEntry
 from ..company.form_field import CollectedData
+from ..company.CRM.funnel import ActiveFunnel
 import json
 import logging
 logger = logging.getLogger(__name__)
@@ -47,6 +48,7 @@ class Chat(CompanyAssetModel):
     chatty_ai_agent: Optional[ChattyAIAgentAssignedToChat] = Field(default=None, description="The id of the chatty ai agent that might or might not be assigned to the chat")
     suggested_messages: List[MessageDraft] = Field(default_factory=list)
     topics_timeline: List[TopicTimelineEntry] = Field(default_factory=list, description="Timeline of conversation topics throughout the conversation")
+    active_funnel: Optional[ActiveFunnel] = Field(default=None, description="Current active funnel for this chat")
     model_config = ConfigDict(extra="ignore")
 
     @property
@@ -267,7 +269,17 @@ class Chat(CompanyAssetModel):
     @property
     def bought_product_ids(self) -> List[StrObjectId]:
         """Get all sale ids in the chat"""
-        return [sale.product_id for sale in self.sales]
+        product_ids: List[StrObjectId] = []
+        for sale in self.sales:
+            sale_product_ids = getattr(sale, "product_ids", None)
+            if sale_product_ids:
+                for product_id in sale_product_ids:
+                    if product_id not in product_ids:
+                        product_ids.append(product_id)
+            elif sale.product_id:
+                if sale.product_id not in product_ids:
+                    product_ids.append(sale.product_id)
+        return product_ids
 
     @property
     def products(self) -> List[AssignedAssetToChat]:
@@ -364,4 +376,3 @@ class Chat(CompanyAssetModel):
             dump["last_message"] = self.last_message.model_dump_json(serializer=SerializerType.DATABASE) if self.last_message else None
             dump["flow_states"] = [flow_state.model_dump_json(serializer=SerializerType.DATABASE) for flow_state in self.flow_states]
         return dump
-

letschatty/models/chat/chat_with_assets.py

@@ -1,6 +1,6 @@
-
 from .chat import Chat
 from letschatty.models.company.assets import TagPreview, FlowPreview, ContactPoint, Sale, ChattyAIAgentPreview, ProductPreview
+from letschatty.models.company.CRM.funnel import ActiveFunnel
 
 from letschatty.models.utils.types.serializer_type import SerializerType
 from pydantic import BaseModel
@@ -15,3 +15,8 @@ class ChatWithAssets(BaseModel):
     contact_points: List[ContactPoint]
     flows_links_states: List[FlowPreview]
     chatty_ai_agent: Optional[ChattyAIAgentPreview]
+
+    @property
+    def active_funnel(self) -> Optional[ActiveFunnel]:
+        """Convenience property to access the chat's active funnel"""
+        return self.chat.active_funnel

letschatty/models/chat/client.py

@@ -5,7 +5,6 @@ from ..utils.types.identifier import StrObjectId
 from .quality_scoring import QualityScore
 from .highlight import Highlight
 from ..company.assets.chat_assets import AssignedAssetToChat, SaleAssignedToChat, ContactPointAssignedToChat
-from ..company.CRM.funnel import ClientFunnel
 from ..utils.types.serializer_type import SerializerType
 
 class Client(CompanyAssetModel):
@@ -23,7 +22,6 @@ class Client(CompanyAssetModel):
     contact_points: List[ContactPointAssignedToChat] = Field(default=list())
     business_area: Optional[StrObjectId] = Field(default=None, description="It's a business related area, that works as a queue for the chats")
     external_id: Optional[str] = Field(default=None)
-    funnels : List[ClientFunnel] = Field(default=list())
     exclude_fields = {
         SerializerType.FRONTEND: {"products", "tags", "sales", "contact_points", "highlights"}
     }

letschatty/models/chat/continuous_conversation.py

@@ -30,7 +30,7 @@ class ContinuousConversation(ChattyAssetModel):
     template_message_waid: Optional[str] = None
     status: Optional[ContinuousConversationStatus] = Field(default=ContinuousConversationStatus.CREATED)
     active: bool = Field(default=True)
-    expires_at: datetime = Field(default=datetime.now(ZoneInfo("UTC")) + timedelta(days=10))
+    expires_at: datetime = Field(default_factory=lambda: datetime.now(ZoneInfo("UTC")) + timedelta(days=10))
     messages: List[MessageDraft]
     creator_id: StrObjectId
     forced_send: bool = Field(default=False)