waldiez 0.3.12__py3-none-any.whl → 0.4.0__py3-none-any.whl

waldiez/models/agents/rag_user/retrieve_config.py

@@ -13,8 +13,11 @@ from ...common import WaldiezBase, check_function, generate_function
 from .vector_db_config import WaldiezRagUserVectorDbConfig
 
 WaldiezRagUserTask = Literal["code", "qa", "default"]
+"""Possible tasks for the retrieve chat."""
 WaldiezRagUserVectorDb = Literal["chroma", "pgvector", "mongodb", "qdrant"]
+"""Possible vector dbs for the retrieve chat."""
 WaldiezRagUserChunkMode = Literal["multi_lines", "one_line"]
+"""Possible chunk modes for the retrieve chat."""
 WaldiezRagUserModels: Dict[WaldiezRagUserVectorDb, str] = {
     "chroma": "all-MiniLM-L6-v2",
     "mongodb": "all-MiniLM-L6-v2",

waldiez/models/agents/reasoning/reasoning_agent_reason_config.py

@@ -8,6 +8,7 @@ from typing_extensions import Annotated, Literal
 from ...common import WaldiezBase
 
 ReasoningConfigMethod = Literal["beam_search", "mcts", "lats", "dfs"]
+"""Possible reasoning methods."""
 
 
 class WaldiezReasoningAgentReasonConfig(WaldiezBase):

waldiez/models/agents/swarm_agent/after_work.py

@@ -17,16 +17,18 @@ from typing_extensions import Annotated, Literal, Self
 from ...common import WaldiezBase, check_function, generate_function
 
 WaldiezSwarmAfterWorkRecipientType = Literal["agent", "option", "callable"]
+"""The possible AfterWork recipient types."""
 WaldiezSwarmAfterWorkOption = Literal[
     "TERMINATE", "REVERT_TO_USER", "STAY", "SWARM_MANAGER"
 ]
+"""The possible AfterWork options."""
 
 
 CUSTOM_AFTER_WORK = "custom_after_work"
 CUSTOM_AFTER_WORK_ARGS = ["last_speaker", "messages", "groupchat"]
 CUSTOM_AFTER_WORK_TYPES = (
-    ["SwarmAgent", "List[Dict[str, Any]]", "GroupChat"],
-    "Union[AfterWorkOption, SwarmAgent, str]",
+    ["ConversableAgent", "List[Dict[str, Any]]", "GroupChat"],
+    "Union[AfterWorkOption, ConversableAgent, str]",
 )
 
 
@@ -45,15 +47,15 @@ class WaldiezSwarmAfterWork(WaldiezBase):
     recipient_type : WaldiezSwarmAfterWorkRecipientType
         The type of recipient.
         Can be 'agent', 'option', or 'callable'.
-        If 'agent', the recipient is a SwarmAgent.
+        If 'agent', the recipient is a Swarm Agent.
         If 'option', the recipient is an AfterWorkOption :
             ('TERMINATE', 'REVERT_TO_USER', 'STAY', 'SWARM_MANAGER').
         If 'callable', it should have the signature:
         def custom_after_work(
-            last_speaker: SwarmAgent,
+            last_speaker: ConversableAgent,
             messages: List[dict],
             groupchat: GroupChat,
-        ) -> Union[AfterWorkOption, SwarmAgent, str]:
+        ) -> Union[AfterWorkOption, ConversableAgent, str]:
 
     """
 
@@ -79,15 +81,15 @@ class WaldiezSwarmAfterWork(WaldiezBase):
             description=(
                 "The type of recipient. "
                 "Can be 'agent', 'option', or 'callable'. "
-                "If 'agent', the recipient is a SwarmAgent.  "
+                "If 'agent', the recipient is a Swarm Agent.  "
                 "If 'option', the recipient is an AfterWorkOption :"
                 "    ('TERMINATE', 'REVERT_TO_USER', 'STAY', 'SWARM_MANAGER'). "
                 "If 'callable', it should have the signature: "
                 "def custom_after_work("
-                "    last_speaker: SwarmAgent,"
+                "    last_speaker: ConversableAgent,"
                 "    messages: List[Dict[str, Any]],"
                 "    groupchat: GroupChat,"
-                ") -> Union[AfterWorkOption, SwarmAgent, str]:"
+                ") -> Union[AfterWorkOption, ConversableAgent, str]:"
             ),
         ),
     ]
@@ -117,13 +119,13 @@ class WaldiezSwarmAfterWork(WaldiezBase):
             The recipient string and the function content if applicable.
         """
         if self.recipient_type == "option":
-            return f"AFTER_WORK(AfterWorkOption.{self.recipient})", ""
+            return f"AfterWork(AfterWorkOption.{self.recipient})", ""
         if self.recipient_type == "agent":
             # the the recipient is passed as the agent name
             # (and not its id), care should be taken to ensure
             # the all the agents in the flow have unique names
             agent_instance = agent_names.get(self.recipient, self.recipient)
-            return f"AFTER_WORK({agent_instance})", ""
+            return f"AfterWork({agent_instance})", ""
 
         function_name = CUSTOM_AFTER_WORK
         if name_prefix:
@@ -131,7 +133,7 @@ class WaldiezSwarmAfterWork(WaldiezBase):
         if name_suffix:
             function_name = f"{function_name}_{name_suffix}"
         return (
-            f"AFTER_WORK({function_name})",
+            f"AfterWork({function_name})",
             generate_function(
                 function_name=function_name,
                 function_args=CUSTOM_AFTER_WORK_ARGS,

waldiez/models/agents/swarm_agent/on_condition.py

@@ -12,6 +12,7 @@ from .on_condition_available import WaldiezSwarmOnConditionAvailable
 from .on_condition_target import WaldiezSwarmOnConditionTarget
 
 WaldiezSwarmOnConditionTargetType = Literal["agent", "nested_chat"]
+"""Possible types for the target of the OnCondition."""
 
 
 class WaldiezSwarmOnCondition(WaldiezBase):
@@ -30,7 +31,7 @@ class WaldiezSwarmOnCondition(WaldiezBase):
         The condition for transitioning to the target agent
 
     available: str, optional
-        Optional condition to determine if this ON_CONDITION is available.
+        Optional condition to determine if this OnCondition is available.
         Can be a Callable or a string.  If a string, it will look up the
         value of the context variable with that name, which should be a bool.
 
@@ -73,7 +74,7 @@ class WaldiezSwarmOnCondition(WaldiezBase):
             default_factory=WaldiezSwarmOnConditionAvailable,
             title="Available",
             description=(
-                "Optional condition to determine if this ON_CONDITION "
+                "Optional condition to determine if this OnCondition "
                 "is available."
             ),
         ),

waldiez/models/agents/swarm_agent/on_condition_available.py

@@ -12,6 +12,7 @@ from ...common import WaldiezBase, check_function, generate_function
 WaldiezSwarmOnConditionAvailableCheckType = Literal[
     "string", "callable", "none"
 ]
+"""Possible types for the `available` check."""
 
 CUSTOM_ON_CONDITION_AVAILABLE = "custom_on_condition_available"
 CUSTOM_ON_CONDITION_AVAILABLE_ARGS = ["agent", "message"]

waldiez/models/agents/swarm_agent/swarm_agent_data.py

@@ -29,7 +29,7 @@ class WaldiezSwarmAgentData(WaldiezAgentData):
         A list of functions (skill ids) to register with the agent.
 
     update_agent_state_before_reply : List[str]
-        A list of functions, including `UPDATE_SYSTEM_MESSAGE`,
+        A list of functions, including `UpdateSystemMessage`,
         called to update the agent's state before it replies. Each function
         is called when the agent is selected and before it speaks.
 
@@ -67,10 +67,10 @@ class WaldiezSwarmAgentData(WaldiezAgentData):
             title="Update Agent State Before Reply",
             alias="updateAgentStateBeforeReply",
             description=(
-                "A list of functions, including UPDATE_SYSTEM_MESSAGEs,"
+                "A list of functions, including UpdateSystemMessage,"
                 "called to update the agent's state before it replies. "
                 " Each function is called when the agent is selected "
-                "and before it speaks. If not an UPDATE_SYSTEM_MESSAGE, "
+                "and before it speaks. If not an UpdateSystemMessage, "
                 "it should be a skill id."
             ),
             default_factory=list,

waldiez/models/agents/swarm_agent/update_system_message.py

@@ -10,6 +10,7 @@ from typing_extensions import Annotated, Literal, Self
 from ...common import WaldiezBase, check_function, generate_function
 
 WaldiezSwarmUpdateFunctionType = Literal["string", "callable"]
+"""Possible types for the update function."""
 
 CUSTOM_UPDATE_SYSTEM_MESSAGE = "custom_update_system_message"
 CUSTOM_UPDATE_SYSTEM_MESSAGE_ARGS = ["agent", "messages"]

waldiez/models/chat/chat_message.py

@@ -12,6 +12,7 @@ from ..common import WaldiezBase, check_function, update_dict
 WaldiezChatMessageType = Literal[
     "string", "method", "rag_message_generator", "none"
 ]
+"""Possible types for the message."""
 
 CALLABLE_MESSAGE = "callable_message"
 CALLABLE_MESSAGE_ARGS = ["sender", "recipient", "context"]

waldiez/models/chat/chat_summary.py

@@ -20,6 +20,7 @@ WaldiezChatSummaryMethod = Literal[
     "reflection_with_llm",
     "last_msg",
 ]
+"""Possible methods for the LLM summary."""
 
 
 class WaldiezChatSummary(WaldiezBase):

waldiez/models/common/__init__.py

@@ -8,6 +8,7 @@ from .date_utils import now
 from .dict_utils import update_dict
 from .method_utils import (
     check_function,
+    gather_code_imports,
     generate_function,
     get_function,
     parse_code_string,
@@ -17,6 +18,7 @@ __all__ = [
     "WaldiezBase",
     "now",
     "check_function",
+    "gather_code_imports",
     "get_autogen_version",
     "get_function",
     "generate_function",

waldiez/models/common/method_utils.py

@@ -3,6 +3,10 @@
 """Function related utilities."""
 
 import ast
+import importlib.util
+import sys
+import sysconfig
+from pathlib import Path
 from typing import List, Optional, Tuple
 
 import parso
@@ -12,6 +16,35 @@ import parso.tree
 MAX_VAR_NAME_LENGTH = 64
 
 
+def is_standard_library(module_name: str) -> bool:
+    """Check if the module is part of the standard library.
+
+    Parameters
+    ----------
+    module_name : str
+        The module name.
+
+    Returns
+    -------
+    bool
+        True if the module is part of the standard library.
+    """
+    if module_name in sys.builtin_module_names:
+        return True
+    try:
+        spec = importlib.util.find_spec(module_name)
+    except BaseException:  # pylint: disable=broad-except
+        return False
+    if spec is None or not spec.origin:
+        return False
+    if "site-packages" in spec.origin:
+        return False
+    if spec.origin.startswith(sys.prefix) or spec.origin == "frozen":
+        return True
+    stdlib_path = str(Path(sysconfig.get_path("stdlib")).resolve())
+    return spec.origin.startswith(stdlib_path)
+
+
 def parse_code_string(
     code_string: str,
 ) -> Tuple[Optional[str], Optional[ast.Module]]:
@@ -38,6 +71,71 @@ def parse_code_string(
     return None, tree
 
 
+def gather_code_imports(
+    code_string: str,
+    is_interop: bool,
+) -> Tuple[List[str], List[str]]:
+    """Gather the imports from the code string.
+
+    Parameters
+    ----------
+    code_string : str
+        The code string.
+    is_interop : bool
+        If True, make sure the interoperability import is present.
+
+    Returns
+    -------
+    Tuple[List[str], List[str]]
+        The standard library imports and the third party imports.
+    """
+    standard_lib_imports: List[str] = []
+    third_party_imports: List[str] = []
+    tree = parso.parse(code_string)  # type: ignore
+    for node in tree.iter_imports():
+        if node.type == "import_name":
+            full_import_statement = node.get_code().strip()
+            module_name = (
+                node.get_code().replace("import", "").strip().split(" ")[0]
+            )
+            if not module_name:
+                continue
+            if is_standard_library(module_name):
+                standard_lib_imports.append(full_import_statement)
+            else:
+                third_party_imports.append(full_import_statement)
+        elif node.type == "import_from":
+            full_import_statement = node.get_code().strip()
+            module_name = (
+                node.get_code().replace("from", "").strip().split(" ")[0]
+            )
+            if not module_name:
+                continue
+            if is_standard_library(module_name):
+                standard_lib_imports.append(full_import_statement)
+            else:
+                third_party_imports.append(full_import_statement)
+    if is_interop and (
+        "from autogen.interop import Interoperability"
+        not in third_party_imports
+    ):
+        third_party_imports.append(
+            "from autogen.interop import Interoperability"
+        )
+    # sorted_standard_lib_imports =  # first import x, then from a import b
+    sorted_standard_lib_imports = sorted(
+        [stmt for stmt in standard_lib_imports if stmt.startswith("import ")]
+    ) + sorted(
+        [stmt for stmt in standard_lib_imports if stmt.startswith("from ")]
+    )
+    sorted_third_party_imports = sorted(
+        [stmt for stmt in third_party_imports if stmt.startswith("import ")]
+    ) + sorted(
+        [stmt for stmt in third_party_imports if stmt.startswith("from ")]
+    )
+    return sorted_standard_lib_imports, sorted_third_party_imports
+
+
 def check_function(
     code_string: str,
     function_name: str,

waldiez/models/model/extra_requirements.py

@@ -36,6 +36,8 @@ def get_models_extra_requirements(
         "bedrock",  # we might add this later
     ]
     for model in models:
+        for requirement in model.requirements:
+            model_requirements.add(requirement)
         if model.data.api_type == "google":
             model_requirements.add(f"pyautogen[gemini]=={autogen_version}")
             continue

waldiez/models/model/model_data.py

@@ -23,6 +23,7 @@ WaldiezModelAPIType = Literal[
     "cohere",
     "other",
 ]
+"""Possible API types for the model."""
 
 
 class WaldiezModelPrice(WaldiezBase):

waldiez/models/skill/__init__.py

@@ -2,11 +2,15 @@
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Waldiez Skill related models."""
 
+from .extra_requirements import get_skills_extra_requirements
 from .skill import SHARED_SKILL_NAME, WaldiezSkill
 from .skill_data import WaldiezSkillData
+from .skill_type import WaldiezSkillType
 
 __all__ = [
     "SHARED_SKILL_NAME",
     "WaldiezSkill",
     "WaldiezSkillData",
+    "WaldiezSkillType",
+    "get_skills_extra_requirements",
 ]

waldiez/models/skill/extra_requirements.py

@@ -0,0 +1,39 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Waldiez skill extra requirements."""
+
+from typing import Iterator, Set
+
+from .skill import WaldiezSkill
+
+
+def get_skills_extra_requirements(
+    skills: Iterator[WaldiezSkill],
+    autogen_version: str,
+) -> Set[str]:
+    """Get the skills extra requirements.
+
+    Parameters
+    ----------
+    skills : List[WaldiezSkill]
+        The skills.
+    autogen_version : str
+        The ag2 version.
+    Returns
+    -------
+    List[str]
+        The skills extra requirements.
+    """
+    skill_requirements: Set[str] = set()
+    for skill in skills:
+        if skill.skill_type == "langchain":
+            skill_requirements.add(
+                f"pyautogen[interop-langchain]=={autogen_version}"
+            )
+        if skill.skill_type == "crewai":
+            skill_requirements.add(
+                f"pyautogen[interop-crewai]=={autogen_version}"
+            )
+        for requirement in skill.requirements:
+            skill_requirements.add(requirement)
+    return skill_requirements

waldiez/models/skill/skill.py

@@ -2,13 +2,23 @@
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Waldiez Skill model."""
 
-from typing import Dict, List
+import json
+import re
+from pathlib import Path
+from typing import Any, Dict, List, Tuple, Union
 
 from pydantic import Field, model_validator
 from typing_extensions import Annotated, Literal, Self
 
-from ..common import WaldiezBase, get_function, now, parse_code_string
+from ..common import (
+    WaldiezBase,
+    gather_code_imports,
+    get_function,
+    now,
+    parse_code_string,
+)
 from .skill_data import WaldiezSkillData
+from .skill_type import WaldiezSkillType
 
 SHARED_SKILL_NAME = "waldiez_shared"
 
@@ -97,6 +107,66 @@ class WaldiezSkill(WaldiezBase):
         ),
     ]
 
+    @staticmethod
+    def load(data_or_path: Union[str, Path, Dict[str, Any]]) -> "WaldiezSkill":
+        """Load a skill from a read-only file.
+
+        Parameters
+        ----------
+        data_or_path : Union[str, Path, Dict[str, Any]]
+            The path to the read-only file or the loaded data.
+
+        Returns
+        -------
+        WaldiezSkill
+            The skill.
+
+        Raises
+        ------
+        FileNotFoundError
+            If the file is not found.
+        ValueError
+            If the JSON is invalid or the data is invalid.
+        """
+        if isinstance(data_or_path, dict):
+            return WaldiezSkill.model_validate(data_or_path)
+        if not isinstance(data_or_path, Path):
+            data_or_path = Path(data_or_path)
+        resolved = data_or_path.resolve()
+        if not resolved.is_file():
+            raise FileNotFoundError(f"File not found: {resolved}")
+        with resolved.open("r", encoding="utf-8") as file:
+            data_string = file.read()
+            try:
+                data_dict = json.loads(data_string)
+            except BaseException as exc:  # pylint: disable=broad-except
+                raise ValueError(f"Invalid WaldiezSkill/JSON: {exc}") from exc
+            return WaldiezSkill.model_validate(data_dict)
+
+    @property
+    def skill_type(self) -> WaldiezSkillType:
+        """Get the skill type.
+
+        Returns
+        -------
+        WaldiezSkillType
+            The type of the skill:
+            [shared, custom, langchain, crewai].
+        """
+        return self.data.skill_type
+
+    _skill_imports: Tuple[List[str], List[str]] = ([], [])
+
+    def get_imports(self) -> Tuple[List[str], List[str]]:
+        """Get the skill imports.
+
+        Returns
+        -------
+        Tuple[List[str], List[str]]
+            The builtin and external imports.
+        """
+        return self._skill_imports
+
     @property
     def is_shared(self) -> bool:
         """Check if the skill is shared.
@@ -106,7 +176,18 @@ class WaldiezSkill(WaldiezBase):
         bool
             True if the skill is shared, False otherwise.
         """
-        return self.name == SHARED_SKILL_NAME
+        return self.skill_type == "shared" or self.name == SHARED_SKILL_NAME
+
+    @property
+    def is_interop(self) -> bool:
+        """Check if the skill is interoperability.
+
+        Returns
+        -------
+        bool
+            True if the skill is interoperability, False otherwise.
+        """
+        return self.skill_type in ("langchain", "crewai")
 
     def get_content(self) -> str:
         """Get the content of the skill.
@@ -116,11 +197,61 @@ class WaldiezSkill(WaldiezBase):
         str
             The content of the skill.
         """
-        if self.name == SHARED_SKILL_NAME:
-            # the whole content (globals)
+        if self.is_shared or self.is_interop:
             return self.data.content
+        # if custom, only the function content
         return get_function(self.data.content, self.name)
 
+    def _validate_interop_skill(self) -> None:
+        """Validate the interoperability skill.
+
+        Raises
+        ------
+        ValueError
+            If the skill name is not in the content.
+        """
+        if self.is_interop:
+            # we expect sth like:
+            # with single or double quotes for type={skill_type}
+            # {skill_name} = *.convert_tool(..., type="{skill_type}", ...)
+            if f"{self.name} = " not in self.data.content:
+                raise ValueError(
+                    f"The skill name '{self.name}' is not in the content."
+                )
+            # we don't want the conversion to ag2 tool (we do it internally)
+            # or the skill registration (we do it after having the agent names)
+            # so no" .convert_tool(... type="...")
+            # or .register_for_llm(...), .register_for_execution(...)
+            to_exclude = [
+                r".convert_tool\(.+?type=",
+                rf"{self.name}.register_for_llm\(",
+                rf"{self.name}.register_for_execution\(",
+            ]
+            for exclude in to_exclude:
+                if re.search(exclude, self.data.content):
+                    raise ValueError(
+                        f"Invalid skill content: '{exclude}' is not allowed."
+                    )
+
+    def _validate_custom_skill(self) -> None:
+        """Validate a custom skill.
+
+        Raises
+        ------
+        ValueError
+            If the skill name is not in the content.
+            If the skill content is invalid.
+        """
+        search = f"def {self.name}("
+        if self.skill_type == "custom" and not self.is_shared:
+            if search not in self.data.content:
+                raise ValueError(
+                    f"The skill name '{self.name}' is not in the content."
+                )
+            error, tree = parse_code_string(self.data.content)
+            if error is not None or tree is None:
+                raise ValueError(f"Invalid skill content: {error}")
+
     @model_validator(mode="after")
     def validate_data(self) -> Self:
         """Validate the data.
@@ -136,14 +267,27 @@ class WaldiezSkill(WaldiezBase):
             If the skill name is not in the content.
             If the skill content is invalid.
         """
-        search = f"def {self.name}("
-        if self.name != SHARED_SKILL_NAME and search not in self.data.content:
-            raise ValueError(
-                f"The skill name '{self.name}' is not in the content."
-            )
-        error, tree = parse_code_string(self.data.content)
-        if error is not None or tree is None:
-            raise ValueError(f"Invalid skill content: {error}")
+        self._validate_custom_skill()
+        self._validate_interop_skill()
+        self._skill_imports = gather_code_imports(
+            self.data.content, self.is_interop
+        )
+        # remove the imports from the content
+        # we 'll place them at the top of the file
+        all_imports = self._skill_imports[0] + self._skill_imports[1]
+        code_lines = self.data.content.splitlines()
+        valid_lines = [
+            line
+            for line in code_lines
+            if not any(line.startswith(imp) for imp in all_imports)
+        ]
+        # remove empty lines at the beginning and end
+        # of the content
+        while valid_lines and not valid_lines[0].strip():
+            valid_lines.pop(0)
+        while valid_lines and not valid_lines[-1].strip():
+            valid_lines.pop()
+        self.data.content = "\n".join(valid_lines)
         return self
 
     @property

waldiez/models/skill/skill_data.py

@@ -8,6 +8,7 @@ from pydantic import Field
 from typing_extensions import Annotated
 
 from ..common import WaldiezBase
+from .skill_type import WaldiezSkillType
 
 
 class WaldiezSkillData(WaldiezBase):
@@ -15,12 +16,25 @@ class WaldiezSkillData(WaldiezBase):
 
     Attributes
     ----------
+    skill_type : WaldiezSkillType
+        The type of the skill: shared, custom, langchain, crewai.
     content : str
         The content (source code) of the skill.
     secrets : Dict[str, str]
         The secrets (environment variables) of the skill.
     """
 
+    skill_type: Annotated[
+        WaldiezSkillType,
+        Field(
+            "custom",
+            alias="skillType",
+            title="Skill Type",
+            description=(
+                "The type of the skill: shared, custom, langchain, crewai."
+            ),
+        ),
+    ] = "custom"
     content: Annotated[
         str,
         Field(

waldiez/models/skill/skill_type.py

@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Waldiez Skill types."""
+
+from typing_extensions import Literal
+
+WaldiezSkillType = Literal["shared", "custom", "langchain", "crewai"]
+"""Possible types of a Waldiez Skill."""