Agent

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"
                )

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_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 get_termination_function(
    self,
    name_prefix: Optional[str] = None,
    name_suffix: Optional[str] = None,
) -> Tuple[str, str]:
    """Get the termination function.

    Parameters
    ----------
    name_prefix : str
        The function name prefix.
    name_suffix : str
        The function name suffix.

    Returns
    -------
    Tuple[str, str]
        The termination function and the function name.
    """
    function_name = "is_termination_message"
    if name_prefix:
        function_name = f"{name_prefix}_{function_name}"
    if name_suffix:
        function_name = f"{function_name}_{name_suffix}"
    if self.type in ("none", "keyword"):
        return self.string, function_name
    return (
        generate_function(
            function_name=function_name,
            function_args=IS_TERMINATION_MESSAGE_ARGS,
            function_types=IS_TERMINATION_MESSAGE_TYPES,
            function_body=self.string,
        ),
        function_name,
    )

@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