waldiez 0.4.7__py3-none-any.whl → 0.4.8__py3-none-any.whl

waldiez/models/chat/chat_data.py

@@ -2,16 +2,21 @@
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Chat data model."""
 
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Optional, Union
 
 from pydantic import Field, field_validator, model_validator
 from typing_extensions import Annotated, Self
 
-from ..agents.swarm_agent import (
-    WaldiezSwarmAfterWork,
-    WaldiezSwarmOnConditionAvailable,
+from ..agents import WaldiezAgentType
+from ..common import (
+    WaldiezBase,
+    WaldiezDefaultCondition,
+    WaldiezHandoffCondition,
+    WaldiezHandoffTransition,
+    WaldiezTransitionAvailability,
+    check_function,
+    update_dict,
 )
-from ..common import WaldiezBase, check_function, update_dict
 from .chat_message import (
     CALLABLE_MESSAGE,
     CALLABLE_MESSAGE_ARGS,
@@ -28,10 +33,10 @@ class WaldiezChatData(WaldiezBase):
     ----------
     name : str
         The name of the chat.
-    source : str
-        The source of the chat (sender).
-    target : str
-        The target of the chat (recipient).
+    source_type : WaldiezAgentType
+        The agent type of the chat source.
+    target_type : WaldiezAgentType
+        The agent type of the chat target.
     description : str
         The description of the chat.
     position : int
@@ -48,83 +53,54 @@ class WaldiezChatData(WaldiezBase):
         The summary method and options for the chat.
     max_turns : Optional[int]
         The maximum number of turns for the chat, by default None (no limit).
-    silent : Optional[bool], optional
-        Whether to run the chat silently, by default None (ignored).
-    summary_args : Optional[Dict[str, Any]]
+    silent : bool, optional
+        Whether to run the chat silently, by default False (not silent).
+    summary_args : Optional[dict[str, Any]]
         The summary args to use in autogen.
+    handoff_condition : Optional[WaldiezHandoffCondition], optional
+        The handoff condition to use, by default None (for group chat).
     real_source : Optional[str]
         The real source of the chat (overrides the source).
     real_target : Optional[str]
         The real target of the chat (overrides the target).
-    max_rounds : int
-        Maximum number of conversation rounds (swarm).
-    after_work : Optional[WaldiezSwarmAfterWork]
-        The work to do after the chat (swarm).
-
-    Functions
-    ---------
-    validate_message(value: Any)
-        Validate the message.
-    validate_summary_method(value: Optional[WaldiezChatSummaryMethod])
-        Validate the summary method.
-    serialize_summary_method(value: Any, info: FieldSerializationInfo)
-        Serialize summary method.
-    get_chat_args()
-        Get the chat arguments to use in autogen.
     """
 
     name: Annotated[
         str, Field(..., title="Name", description="The name of the chat.")
     ]
-    source: Annotated[
-        str,
-        Field(
-            ...,
-            title="Source",
-            description="The source of the chat (sender).",
-        ),
-    ]
-    target: Annotated[
-        str,
-        Field(
-            ...,
-            title="Target",
-            description="The target of the chat (recipient).",
-        ),
-    ]
     description: Annotated[
         str,
         Field(
-            ...,
+            default="A new chat",
             title="Description",
             description="The description of the chat.",
         ),
-    ]
+    ] = "A new chat"
     position: Annotated[
         int,
         Field(
-            -1,
+            default=-1,
             title="Position",
             description="The position of the chat in the flow (Ignored).",
         ),
-    ]
+    ] = -1
     order: Annotated[
         int,
         Field(
-            -1,
+            default=-1,
             title="Order",
             description="The order of the chat in the flow.",
         ),
-    ]
+    ] = -1
     clear_history: Annotated[
-        Optional[bool],
+        bool,
         Field(
-            None,
+            default=True,
             alias="clearHistory",
             title="Clear History",
             description="Whether to clear the chat history.",
         ),
-    ]
+    ] = True
     message: Annotated[
         Union[str, WaldiezChatMessage],
         Field(
@@ -153,84 +129,96 @@ class WaldiezChatData(WaldiezBase):
     max_turns: Annotated[
         Optional[int],
         Field(
-            None,
+            default=None,
             alias="maxTurns",
             title="Max Turns",
             description="The maximum number of turns for the chat.",
         ),
-    ]
+    ] = None
     prerequisites: Annotated[
-        List[str],
+        list[str],
         Field(
             title="Prerequisites",
             description="The prerequisites (chat ids) for the chat (if async).",
             default_factory=list,
         ),
-    ]
+    ] = []
     silent: Annotated[
-        Optional[bool],
+        bool,
         Field(
-            None,
+            default=False,
             title="Silent",
             description="Whether to run the chat silently.",
         ),
-    ]
+    ] = False
     real_source: Annotated[
         Optional[str],
         Field(
-            None,
+            default=None,
             alias="realSource",
             title="Real Source",
             description="The real source of the chat (overrides the source).",
         ),
-    ]
+    ] = None
     real_target: Annotated[
         Optional[str],
         Field(
-            None,
+            default=None,
             alias="realTarget",
             title="Real Target",
             description="The real target of the chat (overrides the target).",
         ),
-    ]
-    max_rounds: Annotated[
-        int,
+    ] = None
+    source_type: Annotated[
+        WaldiezAgentType,
         Field(
-            20,
-            title="Max Rounds",
-            description="Maximum number of conversation rounds.(swarm)",
+            ...,
+            alias="sourceType",
+            title="Source Type",
+            description="The agent type of the source.",
         ),
-    ] = 20
-    after_work: Annotated[
-        Optional[WaldiezSwarmAfterWork],
+    ]
+    target_type: Annotated[
+        WaldiezAgentType,
         Field(
-            None,
-            alias="afterWork",
-            title="After Work",
-            description="The work to do after the chat (swarm).",
+            ...,
+            alias="targetType",
+            title="Target Type",
+            description="The agent type of the target.",
         ),
-    ] = None
-    context_variables: Annotated[
-        Optional[Dict[str, Any]],
+    ]
+    condition: Annotated[
+        WaldiezHandoffCondition,
         Field(
-            None,
-            alias="contextVariables",
-            title="Context Variables",
-            description="The context variables to use in the chat.",
+            default_factory=WaldiezDefaultCondition.create,
+            alias="condition",
+            title="Handoff Condition",
+            description="The handoff condition to use.",
         ),
-    ] = None
+    ]
     available: Annotated[
-        WaldiezSwarmOnConditionAvailable,
+        WaldiezTransitionAvailability,
         Field(
-            default_factory=WaldiezSwarmOnConditionAvailable,
-            title="Available",
-            description="The available condition for the chat.",
+            default_factory=WaldiezTransitionAvailability,
+            title="Availability",
+            description="The availability condition for the chat.",
         ),
     ]
-
+    after_work: Annotated[
+        Optional[WaldiezHandoffTransition],
+        Field(
+            None,
+            title="After Work",
+            description=(
+                "The target to transfer control to after the chat has "
+                "finished its work. (used if in a group chat)"
+            ),
+            alias="afterWork",
+        ),
+    ] = None
     _message_content: Optional[str] = None
     _chat_id: int = 0
-    _prerequisites: List[int] = []
+    _prerequisites: list[int] = []
 
     @property
     def message_content(self) -> Optional[str]:
@@ -257,22 +245,22 @@ class WaldiezChatData(WaldiezBase):
         """
         self._chat_id = value
 
-    def get_prerequisites(self) -> List[int]:
+    def get_prerequisites(self) -> list[int]:
         """Get the chat prerequisites.
 
         Returns
         -------
-        List[int]
+        list[int]
             The chat prerequisites (if async).
         """
         return self._prerequisites
 
-    def set_prerequisites(self, value: List[int]) -> None:
+    def set_prerequisites(self, value: list[int]) -> None:
         """Set the chat prerequisites.
 
         Parameters
         ----------
-        value : List[int]
+        value : list[int]
             The chat prerequisites to set.
         """
         self._prerequisites = value
@@ -309,6 +297,7 @@ class WaldiezChatData(WaldiezBase):
             self._message_content = error_or_body
         return self
 
+    # noinspection PyNestedDecorators
     @field_validator("message", mode="before")
     @classmethod
     def validate_message(cls, value: Any) -> WaldiezChatMessage:
@@ -348,62 +337,36 @@ class WaldiezChatData(WaldiezBase):
             )
         return value
 
-    @field_validator("context_variables", mode="after")
-    @classmethod
-    def validate_context_variables(
-        cls, value: Optional[Dict[str, Any]]
-    ) -> Optional[Dict[str, Any]]:
-        """Validate the context variables.
-
-        Parameters
-        ----------
-        value : Optional[Dict[str, Any]]
-            The context variables value.
-
-        Returns
-        -------
-        Optional[Dict[str, Any]]
-            The validated context variables value.
-
-        Raises
-        ------
-        ValueError
-            If the validation fails.
-        """
-        if value is None:
-            return None
-        return update_dict(value)
-
     @property
-    def summary_args(self) -> Optional[Dict[str, Any]]:
+    def summary_args(self) -> Optional[dict[str, Any]]:
         """Get the summary args."""
         if self.summary.method not in (
             "reflection_with_llm",
             "reflectionWithLlm",
         ):
             return None
-        args: Dict[str, Any] = {}
-        if self.summary.prompt:
+        args: dict[str, Any] = {}
+        if self.summary.prompt:  # pragma: no branch
             args["summary_prompt"] = self.summary.prompt
-        if self.summary.args:
+        if self.summary.args:  # pragma: no branch
             args.update(self.summary.args)
         return args
 
-    def _get_context_args(self) -> Dict[str, Any]:
+    def _get_context_args(self) -> dict[str, Any]:
         """Get the context arguments to use in autogen.
 
         Returns
         -------
-        Dict[str, Any]
+        dict[str, Any]
             The dictionary to use for generating the kwargs.
         """
-        extra_args: Dict[str, Any] = {}
+        extra_args: dict[str, Any] = {}
         if not isinstance(self.message, WaldiezChatMessage):  # pragma: no cover
             return extra_args
         extra_args.update(update_dict(self.message.context))
         return extra_args
 
-    def get_chat_args(self, for_queue: bool) -> Dict[str, Any]:
+    def get_chat_args(self, for_queue: bool) -> dict[str, Any]:
         """Get the chat arguments to use in autogen.
 
         Without the 'message' key.
@@ -415,20 +378,20 @@ class WaldiezChatData(WaldiezBase):
 
         Returns
         -------
-        Dict[str, Any]
+        dict[str, Any]
             The dictionary to pass as kwargs.
         """
-        args: Dict[str, Any] = {}
-        if self.summary.method:
-            args["summary_method"] = self.summary.method
+        args: dict[str, Any] = {}
+        if self.summary.method:  # pragma: no branch
+            args["summary_method"] = str(self.summary.method)
         if self.summary_args:
             args["summary_args"] = self.summary_args
-        if isinstance(self.max_turns, int) and self.max_turns > 0:
+        if (
+            isinstance(self.max_turns, int) and self.max_turns > 0
+        ):  # pragma: no branch
             args["max_turns"] = self.max_turns
-        if isinstance(self.clear_history, bool):
-            args["clear_history"] = self.clear_history
-        if isinstance(self.silent, bool):
-            args["silent"] = self.silent
+        args["clear_history"] = self.clear_history
+        # args["silent"] = self.silent
         args.update(self._get_context_args())
         if for_queue:
             args["chat_id"] = self._chat_id

waldiez/models/chat/chat_message.py

@@ -2,7 +2,7 @@
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Waldiez Message Model."""
 
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 from pydantic import Field, model_validator
 from typing_extensions import Annotated, Literal, Self
@@ -17,12 +17,12 @@ WaldiezChatMessageType = Literal[
 CALLABLE_MESSAGE = "callable_message"
 CALLABLE_MESSAGE_ARGS = ["sender", "recipient", "context"]
 CALLABLE_MESSAGE_TYPES = (
-    ["ConversableAgent", "ConversableAgent", "Dict[str, Any]"],
-    "Union[Dict[str, Any], str]",
+    ["ConversableAgent", "ConversableAgent", "dict[str, Any]"],
+    "Union[dict[str, Any], str]",
 )
 CALLABLE_MESSAGE_RAG_WITH_CARRYOVER_TYPES = (
-    ["RetrieveUserProxyAgent", "ConversableAgent", "Dict[str, Any]"],
-    "Union[Dict[str, Any], str]",
+    ["RetrieveUserProxyAgent", "ConversableAgent", "dict[str, Any]"],
+    "Union[dict[str, Any], str]",
 )
 
 
@@ -52,14 +52,14 @@ class WaldiezChatMessage(WaldiezBase):
         the `{sender}.message_generator` method will be used.
     content : Optional[str]
         The content of the message (string or method).
-    context : Dict[str, Any]
+    context : dict[str, Any]
         Extra context of the message.
     """
 
     type: Annotated[
         WaldiezChatMessageType,
         Field(
-            "none",
+            default="none",
             title="Type",
             description=(
                 "The type of the message: "
@@ -72,34 +72,44 @@ class WaldiezChatMessage(WaldiezBase):
                 "the `sender.message_generator` method will be used."
             ),
         ),
-    ]
+    ] = "none"
     use_carryover: Annotated[
         bool,
         Field(
-            False,
+            default=False,
             title="Use Carryover",
             description="Use the carryover from the context.",
         ),
-    ]
+    ] = False
     content: Annotated[
         Optional[str],
         Field(
-            None,
+            default=None,
             title="Content",
             description="The content of the message (string or method).",
         ),
-    ]
+    ] = None
     context: Annotated[
-        Dict[str, Any],
+        dict[str, Any],
         Field(
             default_factory=dict,
             title="Context",
             description="Extra context of the message.",
         ),
-    ]
+    ] = {}
 
     _content_body: Optional[str] = None
 
+    def is_method(self) -> bool:
+        """Check if the message is a method.
+
+        Returns
+        -------
+        bool
+            True if the message is a method, False otherwise.
+        """
+        return self.type in ("method", "rag_message_generator")
+
     @property
     def content_body(self) -> Optional[str]:
         """Get the content body."""
@@ -144,7 +154,7 @@ class WaldiezChatMessage(WaldiezBase):
             if not self.content:
                 self.content = ""
             if self.use_carryover:
-                content = get_last_carryover_method_content(
+                self.content = get_last_carryover_method_content(
                     text_content=self.content,
                 )
             content = self.content
@@ -162,7 +172,7 @@ class WaldiezChatMessage(WaldiezBase):
     def validate_method(
         self,
         function_name: str,
-        function_args: List[str],
+        function_args: list[str],
     ) -> str:
         """Validate a method.
 
@@ -170,7 +180,7 @@ class WaldiezChatMessage(WaldiezBase):
         ----------
         function_name : str
             The method name.
-        function_args : List[str]
+        function_args : list[str]
             The expected method arguments.
 
         Returns
@@ -219,12 +229,12 @@ def get_last_carryover_method_content(text_content: str) -> str:
         The source agent.
     recipient : ConversableAgent
         The target agent.
-    context : Dict[str, Any]
+    context : dict[str, Any]
         The context.
 
     Returns
     -------
-    Union[Dict[str, Any], str]
+    Union[dict[str, Any], str]
         The message to send using the last carryover.
     """
     carryover = context.get("carryover", "")
@@ -258,12 +268,12 @@ RAG_METHOD_WITH_CARRYOVER_BODY = '''
         The source agent.
     recipient : ConversableAgent
         The target agent.
-    context : Dict[str, Any]
+    context : dict[str, Any]
         The context.
 
     Returns
     -------
-    Union[Dict[str, Any], str]
+    Union[dict[str, Any], str]
         The message to send using the last carryover.
     """
     carryover = context.get("carryover", "")
@@ -285,7 +295,7 @@ RAG_METHOD_WITH_CARRYOVER = (
     "def callable_message(\n"
     "    sender: RetrieveUserProxyAgent,\n"
     "    recipient: ConversableAgent,\n"
-    "    context: Dict[str, Any],\n"
-    ") -> Union[Dict[str, Any], str]:"
+    "    context: dict[str, Any],\n"
+    ") -> Union[dict[str, Any], str]:"
     f"{RAG_METHOD_WITH_CARRYOVER_BODY}"
 )

waldiez/models/chat/chat_nested.py

@@ -16,11 +16,11 @@ NESTED_CHAT_ARGS = ["recipient", "messages", "sender", "config"]
 NESTED_CHAT_TYPES = (
     [
         "ConversableAgent",
-        "List[Dict[str, Any]]",
+        "list[dict[str, Any]]",
         "ConversableAgent",
-        "Dict[str, Any]",
+        "dict[str, Any]",
     ],
-    "Union[Dict[str, Any], str]",
+    "Union[dict[str, Any], str]",
 )
 
 
@@ -38,19 +38,19 @@ class WaldiezChatNested(WaldiezBase):
     message: Annotated[
         Optional[WaldiezChatMessage],
         Field(
-            None,
+            default=None,
             title="Message",
             description="The message in a nested chat (sender -> recipient).",
         ),
-    ]
+    ] = None
     reply: Annotated[
         Optional[WaldiezChatMessage],
         Field(
-            None,
+            default=None,
             title="Reply",
             description="The reply in a nested chat (recipient -> sender).",
         ),
-    ]
+    ] = None
 
     _message_content: Optional[str] = None
     _reply_content: Optional[str] = None
@@ -65,6 +65,7 @@ class WaldiezChatNested(WaldiezBase):
         """Get the reply content."""
         return self._reply_content
 
+    # noinspection PyNestedDecorators
     @field_validator("message", "reply", mode="before")
     @classmethod
     def validate_message(cls, value: Any) -> WaldiezChatMessage:
@@ -113,27 +114,27 @@ class WaldiezChatNested(WaldiezBase):
         ValueError
             If the validation fails.
         """
-        if self.message is not None:
-            self._message_content = self.message.content_body
-            if self.message.type == "none":
-                self._message_content = ""
-            if self.message.type == "string":
-                self._message_content = self.message.content
-            if self.message.type == "method":
-                self._message_content = self.message.validate_method(
-                    function_name=NESTED_CHAT_MESSAGE,
-                    function_args=NESTED_CHAT_ARGS,
-                )
-
-        if self.reply is not None:
-            self._reply_content = self.reply.content_body
-            if self.reply.type == "none":
-                self._reply_content = ""
-            if self.reply.type == "string":
-                self._reply_content = self.reply.content
-            if self.reply.type == "method":
-                self._reply_content = self.reply.validate_method(
-                    function_name=NESTED_CHAT_REPLY,
-                    function_args=NESTED_CHAT_ARGS,
-                )
+        for attr, content_attr, function_name in [
+            ("message", "_message_content", NESTED_CHAT_MESSAGE),
+            ("reply", "_reply_content", NESTED_CHAT_REPLY),
+        ]:  # pragma: no branch
+            attr_value = getattr(self, attr)
+            if attr_value is not None:
+                if isinstance(
+                    attr_value, WaldiezChatMessage
+                ):  # pragma: no branch
+                    setattr(self, content_attr, attr_value.content_body)
+                    if attr_value.type == "none":
+                        setattr(self, content_attr, "")
+                    elif attr_value.type == "string":
+                        setattr(self, content_attr, attr_value.content)
+                    elif attr_value.type == "method":  # pragma: no branch
+                        setattr(
+                            self,
+                            content_attr,
+                            attr_value.validate_method(
+                                function_name=function_name,
+                                function_args=NESTED_CHAT_ARGS,
+                            ),
+                        )
         return self