Chat

def as_handoff(
    self,
) -> WaldiezHandoff:
    """Convert the chat to a handoff.

    Returns
    -------
    WaldiezHandoff
        The handoff representation of the chat.
    """
    target: WaldiezTransitionTarget = WaldiezAgentTarget(
        target_type="AgentTarget",
        value=[self.target],
    )
    return WaldiezHandoff(
        target=target,
        condition=self.condition,
        available=self.available,
    )

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, WaldiezRagUserProxy)
        and sender.is_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.use_carryover is False
        and self.nested_chat.message.type
        in (
            "string",
            "none",
        )
    ):
        return "", ""
    return self._get_nested_chat_function(
        content=self.nested_chat.message_content,
        function_name_base=NESTED_CHAT_MESSAGE,
        name_prefix=name_prefix,
        name_suffix=name_suffix,
    )

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.use_carryover is False
        and self.nested_chat.reply.type
        in (
            "string",
            "none",
        )
    ):
        return "", ""
    return self._get_nested_chat_function(
        content=self.nested_chat.reply_content,
        function_name_base=NESTED_CHAT_REPLY,
        name_prefix=name_prefix,
        name_suffix=name_suffix,
    )

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["nested_chat"] = self.nested_chat.model_dump()
    dump["message"] = self.message.model_dump()
    dump["message_content"] = self.message_content
    dump["max_turns"] = self.max_turns
    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:  # pragma: no branch
        args["summary_method"] = str(self.summary.method)
    if self.summary_args:
        args["summary_args"] = self.summary_args
    if (
        isinstance(self.max_turns, int) and self.max_turns > 0
    ):  # pragma: no branch
        args["max_turns"] = self.max_turns
    args["clear_history"] = self.clear_history
    # 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("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

def is_method(self) -> bool:
    """Check if the message is a method.

    Returns
    -------
    bool
        True if the message is a method, False otherwise.
    """
    return self.type in ("method", "rag_message_generator")

@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:
            self.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.
    """
    for attr, content_attr, function_name in [
        ("message", "_message_content", NESTED_CHAT_MESSAGE),
        ("reply", "_reply_content", NESTED_CHAT_REPLY),
    ]:  # pragma: no branch
        attr_value = getattr(self, attr)
        if attr_value is not None:
            if isinstance(
                attr_value, WaldiezChatMessage
            ):  # pragma: no branch
                setattr(self, content_attr, attr_value.content_body)
                if attr_value.type == "none":
                    setattr(self, content_attr, "")
                elif attr_value.type == "string":
                    setattr(self, content_attr, attr_value.content)
                elif attr_value.type == "method":  # pragma: no branch
                    setattr(
                        self,
                        content_attr,
                        attr_value.validate_method(
                            function_name=function_name,
                            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