waldiez 0.1.0__py3-none-any.whl

waldiez/models/__init__.py

@@ -0,0 +1,107 @@
+"""Waldiez models package.
+
+- Agents (Users, Assistants, Group Managers, etc.).
+- Chat (Messages, Summaries, etc.).
+- Model (LLM config, API type, etc.).
+- Skill (Skills/Tools to be registered).
+- Flow (Flow of the conversation).
+"""
+
+from .agents import (
+    WaldiezAgent,
+    WaldiezAgentCodeExecutionConfig,
+    WaldiezAgentData,
+    WaldiezAgentLinkedSkill,
+    WaldiezAgentNestedChat,
+    WaldiezAgentNestedChatMessage,
+    WaldiezAgents,
+    WaldiezAgentTeachability,
+    WaldiezAgentTerminationMessage,
+    WaldiezAgentType,
+    WaldiezAssistant,
+    WaldiezAssistantData,
+    WaldiezGroupManager,
+    WaldiezGroupManagerData,
+    WaldiezGroupManagerSpeakers,
+    WaldiezGroupManagerSpeakersSelectionMethod,
+    WaldiezGroupManagerSpeakersSelectionMode,
+    WaldiezGroupManagerSpeakersTransitionsType,
+    WaldiezRagUser,
+    WaldiezRagUserChunkMode,
+    WaldiezRagUserData,
+    WaldiezRagUserModels,
+    WaldiezRagUserRetrieveConfig,
+    WaldiezRagUserTask,
+    WaldiezRagUserVectorDb,
+    WaldiezRagUserVectorDbConfig,
+    WaldiezUserProxy,
+    WaldiezUserProxyData,
+)
+from .chat import (
+    WaldiezChat,
+    WaldiezChatData,
+    WaldiezChatMessage,
+    WaldiezChatNested,
+    WaldiezChatSummary,
+    WaldiezChatSummaryMethod,
+)
+from .common import METHOD_ARGS, METHOD_TYPE_HINTS, WaldiezMethodName
+from .flow import WaldiezFlow, WaldiezFlowData
+from .model import (
+    WaldiezModel,
+    WaldiezModelAPIType,
+    WaldiezModelData,
+    WaldiezModelPrice,
+)
+from .skill import WaldiezSkill, WaldiezSkillData
+from .waldiez import Waldiez
+
+# pylint: disable=duplicate-code
+__all__ = [
+    "METHOD_ARGS",
+    "METHOD_TYPE_HINTS",
+    "WaldiezMethodName",
+    "Waldiez",
+    "WaldiezAgent",
+    "WaldiezAgentCodeExecutionConfig",
+    "WaldiezAgentData",
+    "WaldiezAgentLinkedSkill",
+    "WaldiezAgentNestedChat",
+    "WaldiezAgentNestedChatMessage",
+    "WaldiezAgents",
+    "WaldiezAgentTeachability",
+    "WaldiezAgentTerminationMessage",
+    "WaldiezAgentType",
+    "WaldiezAssistant",
+    "WaldiezAssistantData",
+    "WaldiezChat",
+    "WaldiezChatData",
+    "WaldiezChatSummary",
+    "WaldiezChatNested",
+    "WaldiezChatSummaryMethod",
+    "WaldiezFlow",
+    "WaldiezFlowData",
+    "WaldiezGroupManager",
+    "WaldiezGroupManagerData",
+    "WaldiezGroupManagerSpeakers",
+    "WaldiezGroupManagerSpeakersSelectionMethod",
+    "WaldiezGroupManagerSpeakersSelectionMode",
+    "WaldiezGroupManagerSpeakersTransitionsType",
+    "WaldiezChatMessage",
+    "WaldiezModel",
+    "WaldiezModelAPIType",
+    "WaldiezModelData",
+    "WaldiezModelPrice",
+    "WaldiezRagUser",
+    "WaldiezRagUserData",
+    "WaldiezSkill",
+    "WaldiezSkillData",
+    "WaldiezUserProxy",
+    "WaldiezUserProxyData",
+    "WaldiezRagUserRetrieveConfig",
+    "WaldiezRagUserTask",
+    "WaldiezRagUserChunkMode",
+    "WaldiezRagUserVectorDb",
+    "WaldiezRagUserVectorDbConfig",
+    "WaldiezRagUserModels",
+]

waldiez/models/agents/__init__.py

@@ -0,0 +1,65 @@
+"""Agent models."""
+
+from .agent import (
+    WaldiezAgent,
+    WaldiezAgentCodeExecutionConfig,
+    WaldiezAgentData,
+    WaldiezAgentLinkedSkill,
+    WaldiezAgentNestedChat,
+    WaldiezAgentNestedChatMessage,
+    WaldiezAgentTeachability,
+    WaldiezAgentTerminationMessage,
+    WaldiezAgentType,
+)
+from .agents import WaldiezAgents
+from .assistant import WaldiezAssistant, WaldiezAssistantData
+from .group_manager import (
+    WaldiezGroupManager,
+    WaldiezGroupManagerData,
+    WaldiezGroupManagerSpeakers,
+    WaldiezGroupManagerSpeakersSelectionMethod,
+    WaldiezGroupManagerSpeakersSelectionMode,
+    WaldiezGroupManagerSpeakersTransitionsType,
+)
+from .rag_user import (
+    WaldiezRagUser,
+    WaldiezRagUserChunkMode,
+    WaldiezRagUserData,
+    WaldiezRagUserModels,
+    WaldiezRagUserRetrieveConfig,
+    WaldiezRagUserTask,
+    WaldiezRagUserVectorDb,
+    WaldiezRagUserVectorDbConfig,
+)
+from .user_proxy import WaldiezUserProxy, WaldiezUserProxyData
+
+__all__ = [
+    "WaldiezAgent",
+    "WaldiezAgentType",
+    "WaldiezAgents",
+    "WaldiezAssistant",
+    "WaldiezAssistantData",
+    "WaldiezAgentCodeExecutionConfig",
+    "WaldiezAgentData",
+    "WaldiezAgentLinkedSkill",
+    "WaldiezAgentNestedChat",
+    "WaldiezAgentNestedChatMessage",
+    "WaldiezAgentTeachability",
+    "WaldiezAgentTerminationMessage",
+    "WaldiezGroupManager",
+    "WaldiezGroupManagerData",
+    "WaldiezGroupManagerSpeakers",
+    "WaldiezGroupManagerSpeakersSelectionMethod",
+    "WaldiezGroupManagerSpeakersSelectionMode",
+    "WaldiezGroupManagerSpeakersTransitionsType",
+    "WaldiezRagUser",
+    "WaldiezRagUserData",
+    "WaldiezRagUserModels",
+    "WaldiezUserProxy",
+    "WaldiezUserProxyData",
+    "WaldiezRagUserRetrieveConfig",
+    "WaldiezRagUserTask",
+    "WaldiezRagUserChunkMode",
+    "WaldiezRagUserVectorDb",
+    "WaldiezRagUserVectorDbConfig",
+]

waldiez/models/agents/agent/__init__.py

@@ -0,0 +1,21 @@
+"""Base agent class to be inherited by all other agents."""
+
+from .agent import WaldiezAgent, WaldiezAgentType
+from .agent_data import WaldiezAgentData
+from .code_execution import WaldiezAgentCodeExecutionConfig
+from .linked_skill import WaldiezAgentLinkedSkill
+from .nested_chat import WaldiezAgentNestedChat, WaldiezAgentNestedChatMessage
+from .teachability import WaldiezAgentTeachability
+from .termination_message import WaldiezAgentTerminationMessage
+
+__all__ = [
+    "WaldiezAgent",
+    "WaldiezAgentCodeExecutionConfig",
+    "WaldiezAgentData",
+    "WaldiezAgentLinkedSkill",
+    "WaldiezAgentNestedChat",
+    "WaldiezAgentNestedChatMessage",
+    "WaldiezAgentTeachability",
+    "WaldiezAgentTerminationMessage",
+    "WaldiezAgentType",
+]

waldiez/models/agents/agent/agent.py

@@ -0,0 +1,190 @@
+"""Base agent class to be inherited by all agents."""
+
+from typing import List
+
+from pydantic import Field
+from typing_extensions import Annotated, Literal
+
+from ...common import WaldiezBase, now
+from .agent_data import WaldiezAgentData
+from .code_execution import WaldiezAgentCodeExecutionConfig
+
+WaldiezAgentType = Literal["user", "assistant", "manager", "rag_user"]
+
+
+class WaldiezAgent(WaldiezBase):
+    """Waldiez Agent.
+
+    Attributes
+    ----------
+    id : str
+        The ID of the agent.
+    type : Literal["agent"]
+        The type of the "node" in a graph: "agent"
+    agent_type : Literal["user", "assistant", "manager", "rag_user"]
+        The type of the agent
+    name: str
+        The name of the agent.
+    description : str
+        The description of the agent.
+    tags : List[str]
+        Tags for this agent.
+    requirements : List[str]
+        Python requirements for the agent.
+    created_at : str
+        The date and time when the agent was created.
+    updated_at : str
+        The date and time when the agent was last updated.
+    data: WaldiezAgentData
+        The data (properties) of this agent.
+        See `waldiez.models.agents.WaldiezAgentData` for more info.
+
+    Functions
+    ---------
+    validate_linked_skills(skill_ids: List[str], agent_ids: List[str])
+        Validate the skills linked to the agent.
+    validate_linked_models(model_ids: List[str])
+        Validate the models linked to the agent.
+    """
+
+    id: Annotated[
+        str, Field(..., title="ID", description="The agents unique id")
+    ]
+    type: Annotated[
+        Literal["agent"],
+        Field(
+            "agent",
+            title="Type",
+            description="The type of the 'node' in a graph.",
+        ),
+    ]
+    agent_type: Annotated[
+        Literal["user", "assistant", "manager", "rag_user"],
+        Field(
+            ...,
+            title="Agent type",
+            description="The type of the agent: user, assistant, group manager",
+        ),
+    ]
+    name: Annotated[
+        str, Field(..., title="Name", description="The name of the agent")
+    ]
+    description: Annotated[
+        str,
+        Field(
+            "Agent's description",
+            title="Description",
+            description="The description of the agent",
+        ),
+    ]
+    tags: Annotated[
+        List[str],
+        Field(
+            title="Tags",
+            description="Tags of the agent",
+            default_factory=list,
+        ),
+    ]
+    requirements: Annotated[
+        List[str],
+        Field(
+            title="Requirements",
+            description="Python requirements for the agent",
+            default_factory=list,
+        ),
+    ]
+    created_at: Annotated[
+        str,
+        Field(
+            title="Created at",
+            description="The date and time when the agent was created",
+            default_factory=now,
+        ),
+    ]
+    updated_at: Annotated[
+        str,
+        Field(
+            title="Updated at",
+            description="The date and time when the agent was last updated",
+            default_factory=now,
+        ),
+    ]
+    data: Annotated[
+        WaldiezAgentData,
+        Field(
+            title="Data",
+            description="The data (properties) of the agent",
+            default_factory=WaldiezAgentData,
+        ),
+    ]
+
+    def validate_linked_skills(
+        self, skill_ids: List[str], agent_ids: List[str]
+    ) -> None:
+        """Validate the skills.
+
+        Parameters
+        ----------
+        skill_ids : List[str]
+            The list of skill IDs.
+        agent_ids : List[str]
+            The list of agent IDs.
+
+        Raises
+        ------
+        ValueError
+            If a skill or agent is not found
+        """
+        # if the config dict has skills, make sure they can be found
+        for skill in self.data.skills:
+            if skill.id not in skill_ids:
+                raise ValueError(
+                    f"Skill '{skill.id}' not found in agent's {self.id} skills"
+                )
+            if skill.executor_id not in agent_ids:
+                raise ValueError(
+                    f"Agent '{skill.executor_id}' not found in agents"
+                )
+
+    def validate_linked_models(self, model_ids: List[str]) -> None:
+        """Validate the models.
+
+        Parameters
+        ----------
+        model_ids : List[str]
+            The list of model IDs.
+
+        Raises
+        ------
+        ValueError
+            If a model is not found
+        """
+        # if the config dict has models, make sure they can be found
+        for model in self.data.model_ids:
+            if model not in model_ids:
+                raise ValueError(
+                    f"Model '{model}' not found in agent's {self.id} models"
+                )
+
+    def validate_code_execution(self, skill_ids: List[str]) -> None:
+        """Validate the code execution config.
+
+        Parameters
+        ----------
+        skill_ids : List[str]
+            The list of skill IDs.
+
+        Raises
+        ------
+        ValueError
+            If a function is not found
+        """
+        # if the config dict has functions, make sure they can be found
+        if isinstance(
+            self.data.code_execution_config, WaldiezAgentCodeExecutionConfig
+        ):
+            for function in self.data.code_execution_config.functions:
+                if function not in skill_ids:
+                    raise ValueError(
+                        f"Function '{function}' not found in skills"
+                    )

waldiez/models/agents/agent/agent_data.py

@@ -0,0 +1,162 @@
+"""Common data structures for agents."""
+
+from typing import List, Optional, Union
+
+from pydantic import ConfigDict, Field
+from pydantic.alias_generators import to_camel
+from typing_extensions import Annotated, Literal
+
+from ...common import WaldiezBase
+from .code_execution import WaldiezAgentCodeExecutionConfig
+from .linked_skill import WaldiezAgentLinkedSkill
+from .nested_chat import WaldiezAgentNestedChat
+from .teachability import WaldiezAgentTeachability
+from .termination_message import WaldiezAgentTerminationMessage
+
+
+class WaldiezAgentData(WaldiezBase):
+    """Waldiez Agent Data.
+
+    Attributes
+    ----------
+    system_message : Optional[str]
+        The agent's system message. Default: None (depends on the agent's type)
+    human_input_mode : Literal["ALWAYS", "NEVER", "TERMINATE"]
+        The human input mode to use for the agent.
+    code_execution_config : Union[WaldiezAgentCodeExecutionConfig, False]
+        The code execution config. Either False (no execution) or a dict
+    max_tokens : Optional[int]
+        The maximum tokens to use. Default: None (no limit).
+    agent_default_auto_reply : Optional[str]
+        The agent's default auto reply when no input is received.
+    max_consecutive_auto_reply : Optional[int]
+        The maximum number or consecutive auto replies to use
+        before ending the chat. Default: None (no limit).
+    termination : WaldiezAgentTerminationMessage
+        The message termination check to use (keyword, method, none)
+    teachability : WaldiezAgentTeachability
+        The agent teachability configuration.
+    model_ids: List[str]
+        A list of models (their ids) to link with the agent.
+    skills : List[WaldiezAgentLinkedSkill]
+        A list of skills (id and executor) to register.
+    nested_chats : List[WaldiezAgentNestedChat]
+        A list of nested chats (triggered_by, messages), to register.
+    """
+
+    model_config = ConfigDict(
+        extra="forbid",
+        alias_generator=to_camel,
+        populate_by_name=True,
+        # we have a field starting with "model_" (model_ids)
+        # this is protected by default
+        protected_namespaces=(),
+    )
+
+    system_message: Annotated[
+        Optional[str],
+        Field(
+            None,
+            title="System message",
+            description="The agent's system message.",
+            alias="systemMessage",
+        ),
+    ]
+    human_input_mode: Annotated[
+        Literal["ALWAYS", "NEVER", "TERMINATE"],
+        Field(
+            "NEVER",
+            title="Human input mode",
+            description="The human input mode to use for the agent.",
+            alias="humanInputMode",
+        ),
+    ]
+    max_tokens: Annotated[
+        Optional[int],
+        Field(
+            None,
+            title="Max tokens",
+            description="The maximum tokens to use. Default: None (no limit).",
+            alias="maxTokens",
+        ),
+    ]
+    code_execution_config: Annotated[
+        Union[WaldiezAgentCodeExecutionConfig, Literal[False]],
+        Field(
+            False,
+            title="Code execution config",
+            description=(
+                "The code execution config. Either False (no execution) "
+                "or a `WaldiezAgentCodeExecutionConfig` with details"
+            ),
+            alias="codeExecutionConfig",
+        ),
+    ]
+    agent_default_auto_reply: Annotated[
+        Optional[str],
+        Field(
+            None,
+            title="Agent's default auto reply",
+            description=(
+                "The agent's default auto reply when no input is received."
+            ),
+            alias="agentDefaultAutoReply",
+        ),
+    ]
+    max_consecutive_auto_reply: Annotated[
+        Optional[int],
+        Field(
+            None,
+            title="Max consecutive auto reply",
+            description=(
+                "The maximum number or consecutive auto replies to use "
+                "before ending the chat"
+            ),
+            alias="maxConsecutiveAutoReply",
+        ),
+    ]
+    termination: Annotated[
+        WaldiezAgentTerminationMessage,
+        Field(
+            title="Termination",
+            description=(
+                "The message termination check to use (keyword, method, none)"
+            ),
+            default_factory=WaldiezAgentTerminationMessage,
+        ),
+    ]
+    teachability: Annotated[
+        WaldiezAgentTeachability,
+        Field(
+            title="Teachability",
+            description="The agent teachability configuration.",
+            default_factory=WaldiezAgentTeachability,
+        ),
+    ]
+    model_ids: Annotated[
+        List[str],
+        Field(
+            default_factory=list,
+            title="Model IDs",
+            description="A list of models (their ids) to link with the agent.",
+            alias="modelIds",
+        ),
+    ]
+    skills: Annotated[
+        List[WaldiezAgentLinkedSkill],
+        Field(
+            default_factory=list,
+            title="Skills",
+            description=("A list of skills (id and executor) to register."),
+        ),
+    ]
+    nested_chats: Annotated[
+        List[WaldiezAgentNestedChat],
+        Field(
+            default_factory=list,
+            description=(
+                "A list of nested chats (triggered_by, messages), to register."
+            ),
+            alias="nestedChats",
+        ),
+    ]

waldiez/models/agents/agent/code_execution.py

@@ -0,0 +1,71 @@
+"""Waldiez Agent Code Execution Configuration."""
+
+from typing import List, Optional
+
+from pydantic import Field
+from typing_extensions import Annotated
+
+from ...common import WaldiezBase
+
+
+class WaldiezAgentCodeExecutionConfig(WaldiezBase):
+    """Waldiez Agent Code Execution Configuration.
+
+    Attributes
+    ----------
+    work_dir : Optional[str]
+        The working directory for the code execution.
+    use_docker : Optional[bool]
+        Run the code in a docker container.
+    timeout : Optional[float]
+        The timeout for the code execution. By default None (no timeout).
+    last_n_messages : Optional[int]
+        The chat's last n messages to consider for the code execution.
+    functions : Optional[List[str]]
+        If not using docker, a list of function ids to use.
+    """
+
+    work_dir: Annotated[
+        Optional[str],
+        Field(
+            None,
+            title="Working directory",
+            description="The working directory for the code execution.",
+            alias="workDir",
+        ),
+    ]
+    use_docker: Annotated[
+        Optional[bool],
+        Field(
+            None,
+            title="Use docker",
+            description="Run the code in a docker container.",
+            alias="useDocker",
+        ),
+    ]
+    timeout: Annotated[
+        Optional[float],
+        Field(
+            None,
+            title="Timeout",
+            description=(
+                "The timeout for the code execution.Default: No timeout"
+            ),
+        ),
+    ]
+    last_n_messages: Annotated[
+        Optional[int],
+        Field(
+            None,
+            title="Last N Messages",
+            description="The number of previous messages in the chat to use.",
+        ),
+    ]
+    functions: Annotated[
+        List[str],
+        Field(
+            default_factory=list,
+            title="Functions",
+            description="If not using docker, the function ids to use",
+        ),
+    ]

waldiez/models/agents/agent/linked_skill.py

@@ -0,0 +1,30 @@
+"""Waldiez Agent Skill Model."""
+
+from pydantic import Field
+from typing_extensions import Annotated
+
+from ...common import WaldiezBase
+
+
+class WaldiezAgentLinkedSkill(WaldiezBase):
+    """Waldiez Agent Linked Skill.
+
+    Attributes
+    ----------
+    id : str
+        The id of the skill to use.
+    executor_id: str
+        The id of the agent to use that skill.
+    """
+
+    id: Annotated[
+        str, Field(..., title="ID", description="The id of the skill to use.")
+    ]
+    executor_id: Annotated[
+        str,
+        Field(
+            ...,
+            title="Executor ID",
+            description="The id of the agent to use that skill.",
+        ),
+    ]