waldiez 0.1.0__py3-none-any.whl

waldiez/models/agents/agent/nested_chat.py

@@ -0,0 +1,73 @@
+"""Waldiez Agent Nested Chat."""
+
+from typing import List
+
+from pydantic import Field
+from typing_extensions import Annotated
+
+from ...common import WaldiezBase
+
+
+class WaldiezAgentNestedChatMessage(WaldiezBase):
+    """Waldiez Agent nested chat message.
+
+    A reference to a chat's message or reply in a nested chat
+
+    Attributes
+    ----------
+    id : str
+        The id of the chat.
+    is_reply : bool
+        Whether to use the reply in the chat or not.
+    """
+
+    id: Annotated[
+        str, Field(..., title="ID", description="The id of the chat.")
+    ]
+    is_reply: Annotated[
+        bool,
+        Field(
+            False,
+            title="Is reply",
+            description="Whether to use the reply in the chat or not.",
+            alias="isReply",
+        ),
+    ]
+
+
+class WaldiezAgentNestedChat(WaldiezBase):
+    """Waldiez Agent Nested Chat.
+
+    Attributes
+    ----------
+    triggered_by : List[WaldiezAgentNestedChatMessage]
+        A list of chats (id and is_reply) to determine
+        the triggering of the nested chat.
+    messages : List[WaldiezAgentNestedChatMessage]
+        The list of messages (chat ids and 'is_reply'z)
+        to include the in the nested chat registration.
+    """
+
+    triggered_by: Annotated[
+        List[WaldiezAgentNestedChatMessage],
+        Field(
+            title="Triggered By",
+            description=(
+                "A list of chats (id and is_reply) to determine"
+                "the triggering of the nested chat."
+            ),
+            alias="triggeredBy",
+            default_factory=list,
+        ),
+    ]
+    messages: Annotated[
+        List[WaldiezAgentNestedChatMessage],
+        Field(
+            title="Messages",
+            description=(
+                "The list of messages (chat ids and 'is_reply'z)"
+                "to include the in the nested chat registration."
+            ),
+            default_factory=list,
+        ),
+    ]

waldiez/models/agents/agent/teachability.py

@@ -0,0 +1,68 @@
+"""Waldiez Agent Teachability."""
+
+from pydantic import Field
+from typing_extensions import Annotated, Literal
+
+from ...common import WaldiezBase
+
+
+class WaldiezAgentTeachability(WaldiezBase):
+    """Waldiez Agent Teachability.
+
+    Attributes
+    ----------
+    enabled : bool
+        Whether the teachability is enabled.
+    verbosity : Literal[0, 1, 2, 3]
+        The verbosity level of the teachability. Default: 0
+    reset_db : bool
+        Whether to reset the database. Default: False
+    recall_threshold : float
+        The recall threshold. Default: 1.5
+    max_num_retrievals : int
+        The maximum number of retrievals. Default: 10
+    """
+
+    enabled: Annotated[
+        bool,
+        Field(
+            False,
+            title="Enabled",
+            description="Whether the teachability is enabled.",
+        ),
+    ]
+    verbosity: Annotated[
+        Literal[0, 1, 2, 3],
+        Field(
+            0,
+            title="Verbosity",
+            description="The verbosity level of the teachability.",
+        ),
+    ]
+    reset_db: Annotated[
+        bool,
+        Field(
+            False,
+            title="Reset DB",
+            description="Whether to reset the database.",
+            alias="resetDb",
+        ),
+    ]
+    recall_threshold: Annotated[
+        float,
+        Field(
+            1.5,
+            title="Recall threshold",
+            description="The recall threshold.",
+            alias="recallThreshold",
+        ),
+    ]
+    max_num_retrievals: Annotated[
+        int,
+        Field(
+            10,
+            title="Max num retrievals",
+            description="The maximum number of retrievals.",
+            alias="maxMumRetrievals",
+        ),
+    ]

waldiez/models/agents/agent/termination_message.py

@@ -0,0 +1,167 @@
+"""Waldiez Agent Termination Message Check."""
+
+from typing import List, Optional
+
+from pydantic import ConfigDict, Field, model_validator
+from pydantic.alias_generators import to_camel
+from typing_extensions import Annotated, Literal, Self
+
+from ...common import WaldiezBase, WaldiezMethodName, check_function
+
+
+class WaldiezAgentTerminationMessage(WaldiezBase):
+    """Waldiez Agent Termination Message Check.
+
+    Attributes
+    ----------
+    type : Literal["none", "keyword", "method"]
+        The type of the termination check to use: "none", "keyword", "method"
+    keywords : List[str]
+        If the type is "keyword", the keywords to search in the message.
+    criterion : Optional[Literal["found", "ending", "exact"]] = None
+        If the type is "keyword", the criterion to use (e.g.: in, endswith, ==)
+    method_content: Optional[str]
+        If the type is "method", the code of the method to use.
+        The method must be called `is_termination_message`,
+        have one argument (`message`) which is a dict, and
+        return a bool (whether the message is a termination message or not.)
+    string : str
+        The value of the termination message.
+
+    Functions
+    ---------
+    validate_termination_message() -> Self
+        Validate the termination message configuration.
+    """
+
+    model_config = ConfigDict(
+        extra="forbid",
+        alias_generator=to_camel,
+        populate_by_name=True,
+        frozen=False,
+    )
+
+    type: Annotated[
+        Literal["none", "keyword", "method"],
+        Field(
+            "none",
+            title="Type",
+            description=(
+                "The type of the termination check to use: "
+                "none, keyword, method"
+            ),
+        ),
+    ]
+    keywords: Annotated[
+        List[str],
+        Field(
+            default_factory=list,
+            title="Keywords",
+            description=(
+                "If the type is `keyword`,"
+                " the keywords to search in the message."
+            ),
+        ),
+    ]
+    criterion: Annotated[
+        Optional[Literal["found", "ending", "exact"]],
+        Field(
+            "exact",
+            title="Criterion",
+            description=(
+                "If the type is `keyword`, "
+                "the criterion to use (e.g.: in, endswith, ==)"
+            ),
+        ),
+    ]
+    method_content: Annotated[
+        Optional[str],
+        Field(
+            None,
+            title="Method content",
+            description=(
+                "If the type is `method`, the code of the method to use."
+                "The method must be called `is_termination_message`,"
+                "have one argument (`message`) which is a dict, and return a"
+                "bool (whether the message is a termination message or not.)"
+            ),
+        ),
+    ]
+
+    _string: str = "None"
+
+    @property
+    def string(self) -> str:
+        """Get the value of the termination message.
+
+        - If the type is "none", the value is "None".
+        - If the type is "keyword", the value is a lambda function that checks
+            if any of the keywords comply with the criterion.
+        - If the type is "method", the value is the method content.
+
+        Returns
+        -------
+        str
+            The value of the termination message.
+        """
+        return self._string
+
+    def _validate_method_content(self) -> None:
+        """Validate the method content."""
+        if not self.method_content:
+            raise ValueError(
+                "Method content is required for method termination."
+            )
+        expected_function_name: WaldiezMethodName = "is_termination_message"
+        valid, error_or_content = check_function(
+            self.method_content, expected_function_name
+        )
+        if not valid:
+            raise ValueError(error_or_content)
+        self._string = error_or_content
+
+    def _validate_keyword(self) -> None:
+        """Validate the keyword termination configuration."""
+        if not self.keywords:
+            raise ValueError("Keywords are required for keyword termination.")
+        if self.criterion not in ["found", "ending", "exact"]:
+            raise ValueError(f"Invalid criterion: {self.criterion}")
+        # pylint: disable=inconsistent-quotes
+        keywords_str = ", ".join([f'"{keyword}"' for keyword in self.keywords])
+        if self.criterion == "found":
+            self._string = (
+                'lambda x: any(x.get("content", "") and '
+                'keyword in x.get("content", "") '
+                f"for keyword in [{keywords_str}])"
+            )
+        if self.criterion == "ending":
+            self._string = (
+                'lambda x: any(x.get("content", "").endswith(keyword) '
+                f"for keyword in [{keywords_str}])"
+            )
+        if self.criterion == "exact":
+            self._string = (
+                'lambda x: any(x.get("content", "") == keyword '
+                f"for keyword in [{keywords_str}])"
+            )
+
+    @model_validator(mode="after")
+    def validate_termination_message(self) -> Self:
+        """Validate the termination message configuration.
+
+        Raises
+        ------
+        ValueError
+            If the configuration is invalid.
+        Returns
+        -------
+        WaldiezAgentTerminationMessage
+            The validated termination message configuration.
+        """
+        if self.type == "method":
+            self._validate_method_content()
+        if self.type == "keyword":
+            self._validate_keyword()
+        if self.type == "none":
+            self._string = "None"
+        return self

waldiez/models/agents/agents.py

@@ -0,0 +1,129 @@
+"""Waldiez agents model."""
+
+from typing import Iterator, List
+
+from pydantic import Field, model_validator
+from typing_extensions import Annotated, Self
+
+from ..common import WaldiezBase
+from .agent import WaldiezAgent
+from .assistant import WaldiezAssistant
+from .group_manager.group_manager import WaldiezGroupManager
+from .rag_user import WaldiezRagUser
+from .user_proxy import WaldiezUserProxy
+
+
+class WaldiezAgents(WaldiezBase):
+    """Waldiez agents model.
+
+    Attributes
+    ----------
+    users : List[WaldiezUserProxy]
+        User proxy agents.
+    assistants : List[WaldiezAssistant]
+        Assistant agents.
+    managers : List[WaldiezGroupManager]
+        Group chat mangers.
+    rag_users : List[WaldiezRagUser]
+        RAG user agents.
+    """
+
+    users: Annotated[
+        List[WaldiezUserProxy],
+        Field(
+            title="Users.",
+            description="User proxy agents",
+            default_factory=list,
+        ),
+    ]
+    assistants: Annotated[
+        List[WaldiezAssistant],
+        Field(
+            title="Assistants.",
+            description="Assistant agents",
+            default_factory=list,
+        ),
+    ]
+    managers: Annotated[
+        List[WaldiezGroupManager],
+        Field(
+            title="Managers.",
+            description="Group chat mangers",
+            default_factory=list,
+        ),
+    ]
+    rag_users: Annotated[
+        List[WaldiezRagUser],
+        Field(
+            title="RAG Users.",
+            description="RAG user agents",
+            default_factory=list,
+        ),
+    ]
+
+    @property
+    def members(self) -> Iterator[WaldiezAgent]:
+        """Get all agents.
+
+        Yields
+        ------
+        WaldiezAgent
+            The agents.
+        """
+        yield from self.users
+        yield from self.assistants
+        yield from self.managers
+        yield from self.rag_users
+
+    @model_validator(mode="after")
+    def validate_agents(self) -> Self:
+        """Validate the agents.
+
+        - At least two agents are required.
+        - All the agent IDs must be unique.
+
+        Returns
+        -------
+        WaldiezAgents
+            The agents.
+
+        Raises
+        ------
+        ValueError
+            If the agents are invalid.
+        """
+        all_agent_ids = [agent.id for agent in self.members]
+        if len(all_agent_ids) < 2:
+            raise ValueError("At least two agents are required.")
+        if len(all_agent_ids) != len(set(all_agent_ids)):
+            raise ValueError("Agent IDs must be unique.")
+        return self
+
+    def validate_flow(self, model_ids: List[str], skill_ids: List[str]) -> None:
+        """Validate the flow of the agents.
+
+        - Validate the linked models (the referenced model ids must exist).
+        - Validate the linked skills (the referenced skill ids must exist).
+        - Validate the code execution (the referenced functions must exist).
+
+        Parameters
+        ----------
+        model_ids : List[str]
+            The list of model IDs.
+        skill_ids : List[str]
+            The list of skill IDs.
+
+        Raises
+        ------
+        ValueError
+            If the flow is invalid.
+        """
+        all_agent_ids = [agent.id for agent in self.members]
+        for agent in self.members:
+            agent.validate_linked_models(model_ids)
+            agent.validate_linked_skills(skill_ids, agent_ids=all_agent_ids)
+            agent.validate_code_execution(skill_ids=skill_ids)
+            if agent.agent_type == "manager" and isinstance(
+                agent, WaldiezGroupManager
+            ):
+                agent.validate_transitions(agent_ids=all_agent_ids)

waldiez/models/agents/assistant/__init__.py

@@ -0,0 +1,6 @@
+"""Assistant agent model."""
+
+from .assistant import WaldiezAssistant
+from .assistant_data import WaldiezAssistantData
+
+__all__ = ["WaldiezAssistant", "WaldiezAssistantData"]

waldiez/models/agents/assistant/assistant.py

@@ -0,0 +1,41 @@
+"""Assistant agent model."""
+
+from pydantic import Field
+from typing_extensions import Annotated, Literal
+
+from ..agent import WaldiezAgent
+from .assistant_data import WaldiezAssistantData
+
+
+class WaldiezAssistant(WaldiezAgent):
+    """Assistant agent model.
+
+    A `WaldiezAgent` with agent_type `assistant` and
+    default `human_input_mode`: `"NEVER"`
+    See `WaldiezAgent`,`WaldiezAssistantData`,`WaldiezAgentData` for more info.
+
+    Attributes
+    ----------
+    agent_type : Literal["assistant"]
+        The agent type: 'assistant' for an assistant agent
+    data : WaldiezAssistantData
+        The assistant agent's data
+    """
+
+    agent_type: Annotated[
+        Literal["assistant"],
+        Field(
+            "assistant",
+            title="Agent type",
+            description="The agent type in a graph: 'assistant'",
+            alias="agentType",
+        ),
+    ]
+    data: Annotated[
+        WaldiezAssistantData,
+        Field(
+            title="Data",
+            description="The assistant agent's data",
+            default_factory=WaldiezAssistantData,
+        ),
+    ]

waldiez/models/agents/assistant/assistant_data.py

@@ -0,0 +1,29 @@
+"""Assistant agent data model."""
+
+from pydantic import Field
+from typing_extensions import Annotated, Literal
+
+from ..agent import WaldiezAgentData
+
+
+class WaldiezAssistantData(WaldiezAgentData):
+    """Assistant agent data class.
+
+    The data for an agent with `human_input_mode` set to `"ALWAYS"` as default.
+    See the parent's docs (`WaldiezAgentData`) for the rest of the properties.
+
+    Attributes
+    ----------
+    human_input_mode : Literal["ALWAYS", "NEVER", "TERMINATE"]
+        The human input mode, Defaults to `NEVER`
+    """
+
+    human_input_mode: Annotated[
+        Literal["ALWAYS", "NEVER", "TERMINATE"],
+        Field(
+            "NEVER",
+            title="Human input mode",
+            description="The human input mode, Defaults to `NEVER`",
+            alias="humanInputMode",
+        ),
+    ]

waldiez/models/agents/group_manager/__init__.py

@@ -0,0 +1,19 @@
+"""Group chat manger agent."""
+
+from .group_manager import WaldiezGroupManager
+from .group_manager_data import WaldiezGroupManagerData
+from .speakers import (
+    WaldiezGroupManagerSpeakers,
+    WaldiezGroupManagerSpeakersSelectionMethod,
+    WaldiezGroupManagerSpeakersSelectionMode,
+    WaldiezGroupManagerSpeakersTransitionsType,
+)
+
+__all__ = [
+    "WaldiezGroupManager",
+    "WaldiezGroupManagerData",
+    "WaldiezGroupManagerSpeakers",
+    "WaldiezGroupManagerSpeakersSelectionMethod",
+    "WaldiezGroupManagerSpeakersSelectionMode",
+    "WaldiezGroupManagerSpeakersTransitionsType",
+]

waldiez/models/agents/group_manager/group_manager.py

@@ -0,0 +1,87 @@
+"""Group chat manager agent."""
+
+from typing import List, Literal
+
+from pydantic import Field
+from typing_extensions import Annotated
+
+from ..agent import WaldiezAgent
+from .group_manager_data import WaldiezGroupManagerData
+from .speakers import WaldiezGroupManagerSpeakers
+
+
+class WaldiezGroupManager(WaldiezAgent):
+    """Group chat manager agent.
+
+    A `WaldiezAgent` with agent_type `manager`, `human_input_mode`: `"NEVER"`
+    and chat group related config for the agent.
+    Also see `WaldiezAgent`, `WaldiezGroupManagerData`, `WaldiezAgentData`
+
+    Attributes
+    ----------
+    agent_type : Literal["manager"]
+        The agent type: 'manager' for a group manager agent
+    data : WaldiezGroupManagerData
+        The group manager agent's data.
+
+    Functions
+    ---------
+    validate_transitions(agent_ids: List[str])
+        Validate the transitions.
+    """
+
+    agent_type: Annotated[
+        Literal["manager"],
+        Field(
+            "manager",
+            title="Agent type",
+            description="The agent type: 'manager' for a group manager agent",
+            alias="agentType",
+        ),
+    ]
+    data: Annotated[
+        WaldiezGroupManagerData,
+        Field(
+            title="Data",
+            description="The group manager agent's data",
+            default_factory=WaldiezGroupManagerData,
+        ),
+    ]
+
+    def validate_transitions(self, agent_ids: List[str]) -> None:
+        """Validate the transitions.
+
+        If the selection mode is `transition`:
+
+        - if `allow_repeat` is a list of agent_ids,
+                make sure these ids exist.
+        - make sure the `allowed_or_disallowed_transitions` mapping
+                has valid agent ids.
+
+        Parameters
+        ----------
+        agent_ids : List[str]
+            The list of agent IDs.
+
+        Raises
+        ------
+        ValueError
+            If the transitions are invalid.
+        """
+        speakers: WaldiezGroupManagerSpeakers = self.data.speakers
+        if speakers.selection_mode != "transition":
+            return
+        allow_repeat = speakers.allow_repeat
+        if isinstance(allow_repeat, list):
+            for agent_id in allow_repeat:
+                if agent_id not in agent_ids:
+                    raise ValueError(f"Invalid agent id: {agent_id}")
+        for (
+            agent_id,
+            transitions,
+        ) in speakers.allowed_or_disallowed_transitions.items():
+            if agent_id not in agent_ids:
+                raise ValueError(f"Invalid agent id: {agent_id}")
+            for agent_id in transitions:
+                if agent_id not in agent_ids:
+                    raise ValueError(f"Invalid agent id: {agent_id}")