Chat

def get_chat_args(
    self,
    for_queue: bool,
    sender: Optional[WaldiezAgent] = None,
) -> Dict[str, Any]:
    """Get the chat arguments to use in autogen.

    Parameters
    ----------
    for_queue : bool
        Whether to get the chat arguments for a chat queue.
    sender : WaldiezAgent, optional
        The sender agent, to check if it's a RAG user.
    Returns
    -------
    dict
        The chat arguments.
    """
    args_dict = self.data.get_chat_args(for_queue)
    if (
        isinstance(sender, WaldiezRagUser)
        and sender.agent_type == "rag_user"
        and self.message.type == "rag_message_generator"
    ):
        # check for n_results in agent data, to add in context
        n_results = sender.data.retrieve_config.n_results
        if isinstance(n_results, int) and n_results > 0:
            args_dict["n_results"] = n_results
    return args_dict

def get_message_function(
    self,
    name_prefix: Optional[str] = None,
    name_suffix: Optional[str] = None,
    is_rag: bool = False,
) -> Tuple[str, str]:
    """Get the message function.

    Parameters
    ----------
    name_prefix : str
        The function name prefix.
    name_suffix : str
        The function name suffix.
    is_rag : bool
        If the message is from a RAG user.

    Returns
    -------
    Tuple[str, str]
        The message function and the function name.
    """
    if self.message.type in ("string", "none") or (
        not self.message_content and is_rag is False
    ):
        return "", ""
    function_types = CALLABLE_MESSAGE_TYPES
    function_name = CALLABLE_MESSAGE
    if name_prefix:
        function_name = f"{name_prefix}_{function_name}"
    if name_suffix:
        function_name = f"{function_name}_{name_suffix}"
    if is_rag and self.message.type == "rag_message_generator":
        function_types = CALLABLE_MESSAGE_RAG_WITH_CARRYOVER_TYPES
        return (
            generate_function(
                function_name=function_name,
                function_args=CALLABLE_MESSAGE_ARGS,
                function_types=function_types,
                function_body=self.message.content_body
                or RAG_METHOD_WITH_CARRYOVER_BODY,
            ),
            function_name,
        )
    return (
        generate_function(
            function_name=function_name,
            function_args=CALLABLE_MESSAGE_ARGS,
            function_types=function_types,
            function_body=self.message_content or "",
        ),
        function_name,
    )

def get_nested_chat_message_function(
    self,
    name_prefix: Optional[str] = None,
    name_suffix: Optional[str] = None,
) -> Tuple[str, str]:
    """Get the nested chat message function.

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

    Returns
    -------
    Tuple[str, str]
        The nested chat message function and the function name.
    """
    if (
        not self.nested_chat.message
        or self.nested_chat.message.type in ("string", "none")
        or not self.nested_chat.message_content
    ):
        return "", ""
    function_name = NESTED_CHAT_MESSAGE
    if name_prefix:
        function_name = f"{name_prefix}_{function_name}"
    if name_suffix:
        function_name = f"{function_name}_{name_suffix}"
    return (
        generate_function(
            function_name=function_name,
            function_args=NESTED_CHAT_ARGS,
            function_types=NESTED_CHAT_TYPES,
            function_body=self.nested_chat.message_content,
        ),
        function_name,
    )

def get_nested_chat_reply_function(
    self,
    name_prefix: Optional[str] = None,
    name_suffix: Optional[str] = None,
) -> Tuple[str, str]:
    """Get the nested chat reply function.

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

    Returns
    -------
    Tuple[str, str]
        The nested chat reply function and the function name.
    """
    if (
        not self.nested_chat.reply
        or self.nested_chat.reply.type in ("string", "none")
        or not self.nested_chat.reply_content
    ):
        return "", ""
    function_name = NESTED_CHAT_REPLY
    if name_prefix:
        function_name = f"{name_prefix}_{function_name}"
    if name_suffix:
        function_name = f"{function_name}_{name_suffix}"
    return (
        generate_function(
            function_name=function_name,
            function_args=NESTED_CHAT_ARGS,
            function_types=NESTED_CHAT_TYPES,
            function_body=self.nested_chat.reply_content,
        ),
        function_name,
    )

def model_dump(self, **kwargs: Any) -> Dict[str, Any]:
    """Dump the model to a dict including the chat attributes.

    Parameters
    ----------
    kwargs : Any
        The keyword arguments.
    Returns
    -------
    Dict[str, Any]
        The model dump with the chat attributes.
    """
    dump = super().model_dump(**kwargs)
    dump["name"] = self.name
    dump["description"] = self.description
    dump["source"] = self.source
    dump["target"] = self.target
    dump["nested_chat"] = self.nested_chat.model_dump()
    dump["message"] = self.message.model_dump()
    dump["message_content"] = self.message_content
    dump["context_variables"] = self.context_variables
    dump["max_rounds"] = self.max_rounds
    dump["after_work"] = (
        self.after_work.model_dump() if self.after_work else None
    )
    return dump

def set_chat_id(self, value: int) -> None:
    """Set the chat ID.

    Parameters
    ----------
    value : int
        The chat ID.
    """
    self.data.set_chat_id(value)

def set_prerequisites(self, value: List[int]) -> None:
    """Set the chat prerequisites.

    Parameters
    ----------
    value : List[int]
        The chat prerequisites.
    """
    self.data.set_prerequisites(value)

def get_chat_args(self, for_queue: bool) -> Dict[str, Any]:
    """Get the chat arguments to use in autogen.

    Without the 'message' key.

    Parameters
    ----------
    for_queue : bool
        Whether to get the arguments for a chat queue.

    Returns
    -------
    Dict[str, Any]
        The dictionary to pass as kwargs.
    """
    args: Dict[str, Any] = {}
    if self.summary.method:
        args["summary_method"] = self.summary.method
    if self.summary_args:
        args["summary_args"] = self.summary_args
    if isinstance(self.max_turns, int) and self.max_turns > 0:
        args["max_turns"] = self.max_turns
    if isinstance(self.clear_history, bool):
        args["clear_history"] = self.clear_history
    if isinstance(self.silent, bool):
        args["silent"] = self.silent
    args.update(self._get_context_args())
    if for_queue:
        args["chat_id"] = self._chat_id
    if self._prerequisites:
        args["prerequisites"] = self._prerequisites
    return args

def get_chat_id(self) -> int:
    """Get the chat id.

    Returns
    -------
    int
        The chat id.
    """
    return self._chat_id

def get_prerequisites(self) -> List[int]:
    """Get the chat prerequisites.

    Returns
    -------
    List[int]
        The chat prerequisites (if async).
    """
    return self._prerequisites

def set_chat_id(self, value: int) -> None:
    """Set the chat id.

    Parameters
    ----------
    value : int
        The chat id.
    """
    self._chat_id = value

def set_prerequisites(self, value: List[int]) -> None:
    """Set the chat prerequisites.

    Parameters
    ----------
    value : List[int]
        The chat prerequisites to set.
    """
    self._prerequisites = value

@model_validator(mode="after")
def validate_chat_data(self) -> Self:
    """Validate the chat data.

    Returns
    -------
    WaldiezChatData
        The validated chat data.

    Raises
    ------
    ValueError
        If the validation fails.
    """
    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("context_variables", mode="after")
@classmethod
def validate_context_variables(
    cls, value: Optional[Dict[str, Any]]
) -> Optional[Dict[str, Any]]:
    """Validate the context variables.

    Parameters
    ----------
    value : Optional[Dict[str, Any]]
        The context variables value.

    Returns
    -------
    Optional[Dict[str, Any]]
        The validated context variables value.

    Raises
    ------
    ValueError
        If the validation fails.
    """
    if value is None:
        return None
    return update_dict(value)

@field_validator("message", mode="before")
@classmethod
def validate_message(cls, value: Any) -> WaldiezChatMessage:
    """Validate the message.

    Parameters
    ----------
    value : Any
        The message value.

    Returns
    -------
    WaldiezChatMessage
        The validated message value.

    Raises
    ------
    ValueError
        If the validation fails.
    """
    if value is None:
        return WaldiezChatMessage(
            type="none", use_carryover=False, content=None, context={}
        )
    if isinstance(value, (str, int, float, bool)):
        return WaldiezChatMessage(
            type="string",
            use_carryover=False,
            content=str(value),
            context={},
        )
    if isinstance(value, dict):
        return WaldiezChatMessage.model_validate(value)
    if not isinstance(value, WaldiezChatMessage):
        return WaldiezChatMessage(
            type="none", use_carryover=False, content=None, context={}
        )
    return value

@model_validator(mode="after")
def validate_content(self) -> Self:
    """Validate the content (if not a method).

    Returns
    -------
    WaldiezChatMessage
        The validated instance.

    Raises
    ------
    ValueError
        If the content is invalid.
    """
    content: Optional[str] = None
    if self.type == "none":
        content = "None"
    if self.type == "method":
        if not self.content:
            raise ValueError(
                "The message content is required for the method type"
            )
        content = self.content
    if self.type == "string":
        if not self.content:
            self.content = ""
        if self.use_carryover:
            content = get_last_carryover_method_content(
                text_content=self.content,
            )
        content = self.content
    if self.type == "rag_message_generator":
        if self.use_carryover:
            content = get_last_carryover_method_content(
                text_content=self.content or "",
            )
        else:
            content = RAG_METHOD_WITH_CARRYOVER_BODY
            self.content = RAG_METHOD_WITH_CARRYOVER
    self._content_body = content
    return self

@model_validator(mode="after")
def validate_context_vars(self) -> Self:
    """Try to detect bools nulls and numbers from the context values.

    Returns
    -------
    WaldiezChatMessage
        The validated instance.
    """
    self.context = update_dict(self.context)
    return self

def validate_method(
    self,
    function_name: str,
    function_args: List[str],
) -> str:
    """Validate a method.

    Parameters
    ----------
    function_name : str
        The method name.
    function_args : List[str]
        The expected method arguments.

    Returns
    -------
    str
        The validated method body.

    Raises
    ------
    ValueError
        If the validation fails.
    """
    if not self.content:
        raise ValueError(
            "The message content is required for the method type"
        )
    is_valid, error_or_body = check_function(
        code_string=self.content,
        function_name=function_name,
        function_args=function_args,
    )
    if not is_valid:
        raise ValueError(error_or_body)
    return error_or_body

@field_validator("message", "reply", mode="before")
@classmethod
def validate_message(cls, value: Any) -> WaldiezChatMessage:
    """Validate the message.

    Parameters
    ----------
    value : Any
        The value.

    Returns
    -------
    WaldiezChatMessage
        The validated message.

    Raises
    ------
    ValueError
        If the validation fails.
    """
    if not value:
        return WaldiezChatMessage(
            type="none", use_carryover=False, content=None, context={}
        )
    if isinstance(value, str):
        return WaldiezChatMessage(
            type="string", use_carryover=False, content=value, context={}
        )
    if isinstance(value, dict):
        return WaldiezChatMessage.model_validate(value)
    if isinstance(value, WaldiezChatMessage):
        return value
    raise ValueError(f"Invalid message type: {type(value)}")

@model_validator(mode="after")
def validate_nested_chat(self) -> Self:
    """Validate the nested chat.

    Returns
    -------
    WaldiezChatNested
        The validated nested chat.

    Raises
    ------
    ValueError
        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 = ""
        if self.message.type == "string":
            self._message_content = self.message.content
        if self.message.type == "method":
            self._message_content = self.message.validate_method(
                function_name=NESTED_CHAT_MESSAGE,
                function_args=NESTED_CHAT_ARGS,
            )

    if self.reply is not None:
        self._reply_content = self.reply.content_body
        if self.reply.type == "none":
            self._reply_content = ""
        if self.reply.type == "string":
            self._reply_content = self.reply.content
        if self.reply.type == "method":
            self._reply_content = self.reply.validate_method(
                function_name=NESTED_CHAT_REPLY,
                function_args=NESTED_CHAT_ARGS,
            )
    return self

@field_serializer("method")
@classmethod
def serialize_summary_method(
    cls, value: Any, info: FieldSerializationInfo
) -> Any:
    """Serialize summary method.

    Parameters
    ----------
    value : Any
        The value to serialize.
    info : FieldSerializationInfo
        The serialization info.

    Returns
    -------
    Any
        The serialized value.
    """
    if info.by_alias is True:
        if value == "reflection_with_llm":
            return "reflectionWithLlm"
        if value == "last_msg":
            return "lastMsg"
    return value

@field_validator("method", mode="before")
@classmethod
def validate_summary_method(
    cls, value: Optional[WaldiezChatSummaryMethod]
) -> Optional[WaldiezChatSummaryMethod]:
    """Validate the summary method.

    Parameters
    ----------
    value : Optional[WaldiezChatSummaryMethod]
        The passed WaldiezChatSummaryMethod

    Returns
    -------
    Optional[WaldiezChatSummaryMethod]
        The validated message summary method
    """
    if str(value).lower() == "none":
        return None
    if value == "lastMsg":
        return "last_msg"
    if value == "reflectionWithLlm":
        return "reflection_with_llm"
    return value