waldiez 0.3.5__py3-none-any.whl → 0.3.7__py3-none-any.whl

waldiez/models/agents/reasoning/reasoning_agent_data.py

@@ -0,0 +1,116 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Reasoning agent data model."""
+
+from typing import Any, Dict
+
+from pydantic import Field
+from typing_extensions import Annotated, Literal
+
+from ..assistant import WaldiezAssistantData
+from .reasoning_agent_reason_config import WaldiezReasoningAgentReasonConfig
+
+
+class WaldiezReasoningAgentData(WaldiezAssistantData):
+    """Reasoning agent data model."""
+
+    max_depth: Annotated[
+        int,
+        Field(
+            4,
+            title="Maximum depth",
+            description="Maximum depth of the reasoning tree",
+            alias="maxDepth",
+            deprecated=True,
+        ),
+    ] = 4
+    beam_size: Annotated[
+        int,
+        Field(
+            3,
+            title="Beam size",
+            description="Number of parallel reasoning paths to maintain",
+            alias="beamSize",
+            deprecated=True,
+        ),
+    ] = 3
+    answer_approach: Annotated[
+        Literal["pool", "best"],
+        Field(
+            "pool",
+            title="Answer approach",
+            description="How to generate final answer",
+            alias="answerApproach",
+            deprecated=True,
+        ),
+    ] = "pool"
+    verbose: Annotated[
+        bool,
+        Field(
+            True,
+            title="Verbose",
+            description="Whether to show intermediate steps",
+        ),
+    ]
+    reason_config: Annotated[
+        WaldiezReasoningAgentReasonConfig,
+        Field(
+            title="Reason config",
+            description="The reasoning agent's reason configuration",
+            default_factory=WaldiezReasoningAgentReasonConfig,
+            alias="reasonConfig",
+        ),
+    ]
+
+    def get_reasoning_config(self) -> Dict[str, Any]:
+        """Get the reasoning configuration based on the reason_config method.
+
+        Returns
+        -------
+        Dict[str, Any]
+            The reasoning configuration.
+
+        """
+        reason_dict: Dict[str, Any] = {
+            "method": self.reason_config.method,
+            "max_depth": self.reason_config.max_depth,
+            "forest_size": self.reason_config.forest_size,
+            "rating_scale": self.reason_config.rating_scale,
+        }
+        if self.reason_config.method == "beam_search":
+            reason_dict["beam_size"] = self.reason_config.beam_size
+            reason_dict["answer_approach"] = self.reason_config.answer_approach
+        if self.reason_config.method in ("mcts", "lats"):
+            reason_dict["nsim"] = self.reason_config.nsim
+            reason_dict["exploration_constant"] = (
+                self.reason_config.exploration_constant
+            )
+        return reason_dict
+
+
+# reason_config (dict): Configuration for the reasoning method.
+# Supported parameters:
+#     method (str): The search strategy to use. Options:
+#         - "beam_search" (default): Uses beam search with parallel paths
+#         - "mcts": Uses Monte Carlo Tree Search for exploration
+#         - "lats": Uses Language Agent Tree Search with per-step rewards
+#         - "dfs": Uses depth-first search
+#                (equivalent to beam_search with beam_size=1)
+#     Common parameters:
+#         max_depth (int): Maximum depth of reasoning tree (default: 3)
+#         forest_size (int):
+#               Number of independent trees to maintain (default: 1)
+#         rating_scale (int):
+#               Scale for grading responses, e.g. 1-10 (default: 10)
+#     Beam Search specific:
+#         beam_size (int): Number of parallel paths to maintain (default: 3)
+#         answer_approach (str):
+#               How to select final answer, "pool" or "best" (default: "pool")
+#     MCTS/LATS specific:
+#         nsim (int): Number of simulations to run (default: 3)
+#         exploration_constant (float):
+#               UCT exploration parameter (default: 1.41)
+#     Example configs:
+#         `{"method": "beam_search", "beam_size": 5, "max_depth": 4}`
+#         `{"method": "mcts", "nsim": 10, "exploration_constant": 2.0}`
+#         `{"method": "lats", "nsim": 5, "forest_size": 3}`

waldiez/models/agents/reasoning/reasoning_agent_reason_config.py

@@ -0,0 +1,101 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Reasoning agent's reason configuration model."""
+
+from pydantic import Field
+from typing_extensions import Annotated, Literal
+
+from ...common import WaldiezBase
+
+ReasoningConfigMethod = Literal["beam_search", "mcts", "lats", "dfs"]
+
+
+class WaldiezReasoningAgentReasonConfig(WaldiezBase):
+    """Reasoning agent's reason configuration model.
+
+    Configuration for the reasoning method.
+
+    Attributes
+    ----------
+    method : Literal["beam_search", "mcts", "lats", "dfs"]
+        The search strategy to use, default is "beam_search".
+    max_depth : int
+        Maximum depth of reasoning tree, default is 3.
+    forest_size : int
+        Number of independent trees to maintain, default is 1.
+    rating_scale : int
+        Scale for grading responses, e.g. 1-10, default is 10.
+    beam_size : int
+        Number of parallel paths to maintain, default is 3 (for beam_search).
+    answer_approach : Literal["pool", "best"]
+        How to select final answer, default is "pool" (only for beam_search).
+    nsim : int
+        Number of simulations to run, default is 3 (only for mcts and lats).
+    exploration_constant : float
+        UCT exploration parameter, default is 1.41 (only for mcts and lats).
+    """
+
+    method: Annotated[
+        ReasoningConfigMethod,
+        Field(
+            "beam_search",
+            title="Method",
+            description="The search strategy to use.",
+        ),
+    ]
+    max_depth: Annotated[
+        int,
+        Field(
+            3,
+            title="Maximum depth",
+            description="Maximum depth of reasoning tree.",
+        ),
+    ]
+    forest_size: Annotated[
+        int,
+        Field(
+            1,
+            title="Forest size",
+            description="Number of independent trees to maintain.",
+        ),
+    ]
+    rating_scale: Annotated[
+        int,
+        Field(
+            10,
+            title="Rating scale",
+            description="Scale for grading responses, e.g. 1-10.",
+        ),
+    ]
+    beam_size: Annotated[
+        int,
+        Field(
+            3,
+            title="Beam size",
+            description="Number of parallel paths to maintain.",
+        ),
+    ]
+    answer_approach: Annotated[
+        Literal["pool", "best"],
+        Field(
+            "pool",
+            title="Answer approach",
+            description="How to select final answer.",
+        ),
+    ]
+    nsim: Annotated[
+        int,
+        Field(
+            3,
+            title="Number of simulations",
+            description="Number of simulations to run.",
+        ),
+    ]
+    exploration_constant: Annotated[
+        float,
+        Field(
+            1.41,
+            title="Exploration constant",
+            description="UCT exploration parameter.",
+        ),
+    ]

waldiez/models/agents/swarm_agent/__init__.py

@@ -19,7 +19,7 @@ from .on_condition_available import (
 )
 from .on_condition_target import WaldiezSwarmOnConditionTarget
 from .swarm_agent import WaldiezSwarmAgent
-from .swarm_agent_data import WaldiezSwarmAgentData
+from .swarm_agent_data import WaldiezSwarmAgentData, WaldiezSwarmHandoff
 from .update_system_message import (
     CUSTOM_UPDATE_SYSTEM_MESSAGE,
     CUSTOM_UPDATE_SYSTEM_MESSAGE_ARGS,
@@ -42,6 +42,7 @@ __all__ = [
     "WaldiezSwarmAgent",
     "WaldiezSwarmAgentData",
     "WaldiezSwarmAfterWorkRecipientType",
+    "WaldiezSwarmHandoff",
     "WaldiezSwarmOnCondition",
     "WaldiezSwarmOnConditionTarget",
     "WaldiezSwarmOnConditionAvailable",

waldiez/models/agents/swarm_agent/swarm_agent_data.py

@@ -13,6 +13,8 @@ from .after_work import WaldiezSwarmAfterWork
 from .on_condition import WaldiezSwarmOnCondition
 from .update_system_message import WaldiezSwarmUpdateSystemMessage
 
+WaldiezSwarmHandoff = Union[WaldiezSwarmOnCondition, WaldiezSwarmAfterWork]
+
 
 # flake8: noqa: E501
 # pylint: disable=line-too-long
@@ -118,8 +120,5 @@ class WaldiezSwarmAgentData(WaldiezAgentData):
         ]
         on_conditions = sorted(on_conditions, key=lambda x: x.target.order)
         handoffs = on_conditions + after_works
-        if after_works and after_works[0] != handoffs[-1]:
-            handoffs.remove(after_works[0])
-            handoffs.append(after_works[0])
         self.handoffs = handoffs
         return self

waldiez/models/chat/chat_data.py

@@ -11,7 +11,7 @@ from ..agents.swarm_agent import (
     WaldiezSwarmAfterWork,
     WaldiezSwarmOnConditionAvailable,
 )
-from ..common import WaldiezBase, check_function
+from ..common import WaldiezBase, check_function, update_dict
 from .chat_message import (
     CALLABLE_MESSAGE,
     CALLABLE_MESSAGE_ARGS,
@@ -291,22 +291,22 @@ class WaldiezChatData(WaldiezBase):
         ValueError
             If the validation fails.
         """
-        if isinstance(self.message, WaldiezChatMessage):
-            if self.message.type == "none":
-                self._message_content = None
-            elif self.message.type == "string":
-                self._message_content = self.message.content
-            elif self.message.type == "method":
-                valid, error_or_body = check_function(
-                    self.message.content or "",
-                    CALLABLE_MESSAGE,
-                    CALLABLE_MESSAGE_ARGS,
-                )
-                if not valid:
-                    raise ValueError(error_or_body)
-                self._message_content = error_or_body
-            else:
-                self._message_content = self.message.content
+        if not isinstance(self.message, WaldiezChatMessage):  # pragma: no cover
+            return self
+        self._message_content = self.message.content
+        if self.message.type == "none":
+            self._message_content = None
+        if self.message.type == "string":
+            self._message_content = self.message.content
+        if self.message.type == "method":
+            valid, error_or_body = check_function(
+                self.message.content or "",
+                CALLABLE_MESSAGE,
+                CALLABLE_MESSAGE_ARGS,
+            )
+            if not valid:
+                raise ValueError(error_or_body)
+            self._message_content = error_or_body
         return self
 
     @field_validator("message", mode="before")
@@ -342,20 +342,22 @@ class WaldiezChatData(WaldiezBase):
             )
         if isinstance(value, dict):
             return WaldiezChatMessage.model_validate(value)
-        if isinstance(value, WaldiezChatMessage):
-            return value
-        return WaldiezChatMessage(
-            type="none", use_carryover=False, content=None, context={}
-        )
+        if not isinstance(value, WaldiezChatMessage):
+            return WaldiezChatMessage(
+                type="none", use_carryover=False, content=None, context={}
+            )
+        return value
 
     @field_validator("context_variables", mode="after")
     @classmethod
-    def validate_context_variables(cls, value: Any) -> Optional[Dict[str, Any]]:
+    def validate_context_variables(
+        cls, value: Optional[Dict[str, Any]]
+    ) -> Optional[Dict[str, Any]]:
         """Validate the context variables.
 
         Parameters
         ----------
-        value : Any
+        value : Optional[Dict[str, Any]]
             The context variables value.
 
         Returns
@@ -370,9 +372,7 @@ class WaldiezChatData(WaldiezBase):
         """
         if value is None:
             return None
-        if not isinstance(value, dict):
-            raise ValueError("Context variables must be a dictionary.")
-        return get_context_dict(value)
+        return update_dict(value)
 
     @property
     def summary_args(self) -> Optional[Dict[str, Any]]:
@@ -398,8 +398,9 @@ class WaldiezChatData(WaldiezBase):
             The dictionary to use for generating the kwargs.
         """
         extra_args: Dict[str, Any] = {}
-        if isinstance(self.message, WaldiezChatMessage):
-            extra_args.update(get_context_dict(self.message.context))
+        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]:
@@ -434,37 +435,3 @@ class WaldiezChatData(WaldiezBase):
         if self._prerequisites:
             args["prerequisites"] = self._prerequisites
         return args
-
-
-def get_context_dict(context: Dict[str, Any]) -> Dict[str, Any]:
-    """Get the context dictionary.
-
-    Try to determine the type of the context variables.
-
-    Parameters
-    ----------
-    context : Dict[str, Any]
-        The context variables.
-
-    Returns
-    -------
-    Dict[str, Any]
-        The context variables with the detected types.
-    """
-    new_dict: Dict[str, Any] = {}
-    for key, value in context.items():
-        value_lower = str(value).lower()
-        if value_lower in ("none", "null"):
-            new_dict[key] = None
-        elif value_lower in ("true", "false"):
-            new_dict[key] = value.lower() == "true"
-        elif str(value).isdigit():
-            new_dict[key] = int(value)
-        elif str(value).replace(".", "").isdigit():
-            try:
-                new_dict[key] = float(value)
-            except ValueError:  # pragma: no cover
-                new_dict[key] = value
-        else:
-            new_dict[key] = value
-    return new_dict

waldiez/models/chat/chat_message.py

@@ -7,7 +7,7 @@ from typing import Any, Dict, List, Optional
 from pydantic import Field, model_validator
 from typing_extensions import Annotated, Literal, Self
 
-from ..common import WaldiezBase, check_function
+from ..common import WaldiezBase, check_function, update_dict
 
 WaldiezChatMessageType = Literal[
     "string", "method", "rag_message_generator", "none"
@@ -113,33 +113,9 @@ class WaldiezChatMessage(WaldiezBase):
         WaldiezChatMessage
             The validated instance.
         """
-        for key, value in self.context.items():
-            if isinstance(value, str):
-                if value.lower() == "true":
-                    self.context[key] = True
-                elif value.lower() == "false":
-                    self.context[key] = False
-                elif value.lower() in ["null", "none"]:
-                    self.context[key] = None
-                else:
-                    self.context[key] = self._number_or_string(value)
+        self.context = update_dict(self.context)
         return self
 
-    @staticmethod
-    def _number_or_string(value: Any) -> Any:
-        try:
-            int_value = int(value)
-            if str(int_value) == value:
-                return int_value
-        except ValueError:
-            try:
-                float_value = float(value)
-                if str(float_value) == value:
-                    return float_value
-            except ValueError:
-                pass
-        return value
-
     @model_validator(mode="after")
     def validate_content(self) -> Self:
         """Validate the content (if not a method).

waldiez/models/chat/chat_nested.py

@@ -114,27 +114,26 @@ class WaldiezChatNested(WaldiezBase):
             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 = ""
-            elif self.message.type == "string":
+            if self.message.type == "string":
                 self._message_content = self.message.content
-            elif self.message.type == "method":
+            if self.message.type == "method":
                 self._message_content = self.message.validate_method(
                     function_name=NESTED_CHAT_MESSAGE,
                     function_args=NESTED_CHAT_ARGS,
                 )
-            else:
-                self._message_content = self.message.content_body
+
         if self.reply is not None:
+            self._reply_content = self.reply.content_body
             if self.reply.type == "none":
                 self._reply_content = ""
-            elif self.reply.type == "string":
+            if self.reply.type == "string":
                 self._reply_content = self.reply.content
-            elif self.reply.type == "method":
+            if self.reply.type == "method":
                 self._reply_content = self.reply.validate_method(
                     function_name=NESTED_CHAT_REPLY,
                     function_args=NESTED_CHAT_ARGS,
                 )
-            else:
-                self._reply_content = self.reply.content_body
         return self

waldiez/models/common/__init__.py

@@ -2,9 +2,9 @@
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Common utils for all models."""
 
-from datetime import datetime, timezone
-
 from .base import WaldiezBase
+from .date_utils import now
+from .dict_utils import update_dict
 from .method_utils import (
     check_function,
     generate_function,
@@ -12,22 +12,6 @@ from .method_utils import (
     parse_code_string,
 )
 
-
-def now() -> str:
-    """Get the current date and time in UTC.
-
-    Returns
-    -------
-    str
-        The current date and time in UTC.
-    """
-    return (
-        datetime.now(tz=timezone.utc)
-        .isoformat(timespec="milliseconds")
-        .replace("+00:00", "Z")
-    )
-
-
 __all__ = [
     "WaldiezBase",
     "now",
@@ -35,4 +19,5 @@ __all__ = [
     "get_function",
     "generate_function",
     "parse_code_string",
+    "update_dict",
 ]

waldiez/models/common/date_utils.py

@@ -0,0 +1,18 @@
+"""Date utilities."""
+
+from datetime import datetime, timezone
+
+
+def now() -> str:
+    """Get the current date and time in UTC.
+
+    Returns
+    -------
+    str
+        The current date and time in UTC.
+    """
+    return (
+        datetime.now(tz=timezone.utc)
+        .isoformat(timespec="milliseconds")
+        .replace("+00:00", "Z")
+    )

waldiez/models/common/dict_utils.py

@@ -0,0 +1,37 @@
+"""Dictionary related utilities."""
+
+from typing import Any, Dict
+
+
+def update_dict(original: Dict[str, Any]) -> Dict[str, Any]:
+    """
+
+    Try to determine the type of the dictionary values.
+
+    Parameters
+    ----------
+    original : Dict[str, Any]
+        The original dictionary.
+
+    Returns
+    -------
+    Dict[str, Any]
+        The updated dictionary with values converted to the detected types.
+    """
+    new_dict: Dict[str, Any] = {}
+    for key, value in original.items():
+        value_lower = str(value).lower()
+        if value_lower in ("none", "null"):
+            new_dict[key] = None
+        elif value_lower in ("true", "false"):
+            new_dict[key] = value_lower == "true"
+        elif str(value).isdigit():
+            new_dict[key] = int(value)
+        elif str(value).replace(".", "").isdigit():
+            try:
+                new_dict[key] = float(value)
+            except ValueError:  # pragma: no cover
+                new_dict[key] = value
+        else:
+            new_dict[key] = value
+    return new_dict

waldiez/models/common/method_utils.py

@@ -114,7 +114,7 @@ def _validate_function_body(
                             f" in function {node.name}"
                         ),
                     )
-            if not node.body:
+            if not node.body:  # pragma: no cover
                 return False, "No body found in the function"
             function_body = _get_function_body(code_string, node)
             return True, function_body
@@ -143,10 +143,7 @@ def get_function(
     str
         The function signature and body.
     """
-    try:
-        tree = parso.parse(code_string)  # type: ignore
-    except BaseException:  # pylint: disable=broad-except
-        return ""
+    tree = parso.parse(code_string)  # type: ignore
     for node in tree.iter_funcdefs():
         if node.name.value == function_name:
             return node.get_code()

waldiez/models/flow/flow_data.py

@@ -151,7 +151,7 @@ class WaldiezFlowData(WaldiezBase):
         for chat in self.chats:
             chat_prerequisites = []
             for chat_id in chat.data.prerequisites:
-                if chat_id not in id_to_chat_id:
+                if chat_id not in id_to_chat_id:  # pragma: no cover
                     raise ValueError(
                         f"Chat with id {chat_id} not found in the flow."
                     )

waldiez/models/waldiez.py

@@ -230,7 +230,7 @@ class Waldiez:
             requirements.add(f"pyautogen=={autogen_version}")
         if self.has_multimodal_agents:
             requirements.add(f"pyautogen[lmm]=={autogen_version}")
-        # ref: https://github.com/ag2ai/ag2/blob/main/setup.py
+        # ref: https://github.com/ag2ai/ag2/blob/main/pyproject.toml
         models_with_additional_requirements = [
             "together",
             "gemini",
@@ -241,6 +241,9 @@ class Waldiez:
             "bedrock",
         ]
         for model in self.models:
+            if model.data.api_type == "google":
+                requirements.add(f"pyautogen[gemini]=={autogen_version}")
+                continue
             if model.data.api_type in models_with_additional_requirements:
                 requirements.add(
                     f"pyautogen[{model.data.api_type}]=={autogen_version}"

waldiez/runner.py

@@ -14,7 +14,7 @@ import sys
 import tempfile
 from pathlib import Path
 from types import TracebackType
-from typing import TYPE_CHECKING, List, Optional, Type, Union
+from typing import TYPE_CHECKING, Dict, List, Optional, Type, Union
 
 from asyncer import syncify
 
@@ -164,7 +164,7 @@ class WaldiezRunner:
         output_path: Optional[Union[str, Path]],
         uploads_root: Optional[Union[str, Path]],
         skip_mmd: bool = False,
-    ) -> Union["ChatResult", List["ChatResult"]]:
+    ) -> Union["ChatResult", List["ChatResult"], Dict[int, "ChatResult"]]:
         """Run the Waldiez workflow.
 
         Parameters
@@ -223,7 +223,7 @@ class WaldiezRunner:
         output_path: Optional[Union[str, Path]],
         uploads_root: Optional[Union[str, Path]],
         skip_mmd: bool = False,
-    ) -> Union["ChatResult", List["ChatResult"]]:
+    ) -> Union["ChatResult", List["ChatResult"], Dict[int, "ChatResult"]]:
         """Run the Waldiez workflow asynchronously."""
         temp_dir = Path(tempfile.mkdtemp())
         file_name = before_run(output_path, uploads_root)