camel-ai 0.1.1__py3-none-any.whl

camel/memories/chat_history_memory.py

@@ -0,0 +1,111 @@
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+# Licensed under the Apache License, Version 2.0 (the “License”);
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an “AS IS” BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+from typing import List, Optional, Tuple
+
+from camel.memories import BaseMemory, ContextRecord, MemoryRecord
+from camel.memories.context_creators import BaseContextCreator
+from camel.messages import OpenAIMessage
+from camel.storages import BaseKeyValueStorage, InMemoryKeyValueStorage
+from camel.types import OpenAIBackendRole
+
+
+class ChatHistoryMemory(BaseMemory):
+    r"""An implementation of the :obj:`BaseMemory` abstract base class for
+    maintaining a record of chat histories.
+
+    This memory class helps manage conversation histories with a designated
+    storage mechanism, either provided by the user or using a default
+    in-memory storage. It offers a windowed approach to retrieving chat
+    histories, allowing users to specify how many recent messages they'd
+    like to fetch.
+
+    `ChatHistoryMemory` requires messages to be stored with certain
+    metadata (e.g., `role_at_backend`) to maintain consistency and validate
+    the chat history.
+
+    Args:
+        context_creator (BaseContextCreator): A context creator contianing
+            the context limit and the message pruning strategy.
+        storage (BaseKeyValueStorage, optional): A storage mechanism for
+            storing chat history. If `None`, an :obj:`InMemoryKeyValueStorage`
+            will be used. (default: :obj:`None`)
+        window_size (int, optional): Specifies the number of recent chat
+            messages to retrieve. If not provided, the entire chat history
+            will be retrieved. (default: :obj:`None`)
+    """
+
+    def __init__(
+        self,
+        context_creator: BaseContextCreator,
+        storage: Optional[BaseKeyValueStorage] = None,
+        window_size: Optional[int] = None,
+    ) -> None:
+        self.context_creator = context_creator
+        self.storage = storage or InMemoryKeyValueStorage()
+        self.window_size = window_size
+
+    def get_context(self) -> Tuple[List[OpenAIMessage], int]:
+        r"""Gets chat context with a proper size for the agent from the memory
+        based on the window size or fetches the entire chat history if no
+        window size is specified.
+
+        Returns:
+            (List[OpenAIMessage], int): A tuple containing the constructed
+                context in OpenAIMessage format and the total token count.
+        Raises:
+            ValueError: If the memory is empty or if the first message in the
+                memory is not a system message.
+        """
+        record_dicts = self.storage.load()
+        if len(record_dicts) == 0:
+            raise ValueError("The `ChatHistoryMemory` is empty.")
+
+        chat_records: List[MemoryRecord] = []
+        truncate_idx = -self.window_size if self.window_size is not None else 0
+        for record_dict in record_dicts[truncate_idx:]:
+            chat_records.append(MemoryRecord.from_dict(record_dict))
+
+        # We assume that, in the chat history memory, the closer the record is
+        # to the current message, the more score it will be.
+        output_records = []
+        score = 1.0
+        for record in reversed(chat_records):
+            if record.role_at_backend == OpenAIBackendRole.SYSTEM:
+                # System messages are always kept.
+                output_records.append(ContextRecord(record, 1.0))
+            else:
+                # Other messages' score drops down gradually
+                score *= 0.99
+                output_records.append(ContextRecord(record, score))
+
+        output_records.reverse()
+        return self.context_creator.create_context(output_records)
+
+    def write_records(self, records: List[MemoryRecord]) -> None:
+        r"""Writes memory records to the memory. Additionally, performs
+        validation checks on the messages.
+
+        Args:
+            records (List[MemoryRecord]): Memory records to be added to the
+                memory.
+        """
+        stored_records = []
+        for record in records:
+            stored_records.append(record.to_dict())
+        self.storage.save(stored_records)
+
+    def clear(self) -> None:
+        r"""Clears all chat messages from the memory.
+        """
+        self.storage.clear()

camel/memories/context_creators/__init__.py

@@ -0,0 +1,18 @@
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+# Licensed under the Apache License, Version 2.0 (the “License”);
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an “AS IS” BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+
+from .base import BaseContextCreator
+from .score_based import ScoreBasedContextCreator
+
+__all__ = ['BaseContextCreator', 'ScoreBasedContextCreator']

camel/memories/context_creators/base.py

@@ -0,0 +1,72 @@
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+# Licensed under the Apache License, Version 2.0 (the “License”);
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an “AS IS” BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+from abc import ABC, abstractmethod
+from typing import List, Tuple
+
+from camel.memories import ContextRecord
+from camel.messages import OpenAIMessage
+from camel.utils import BaseTokenCounter
+
+
+class BaseContextCreator(ABC):
+    r"""An abstract base class defining the interface for context creation
+    strategies.
+
+    This class provides a foundational structure for different strategies to
+    generate conversational context from a list of context records. The
+    primary goal is to create a context that is aligned with a specified token
+    count limit, allowing subclasses to define their specific approach.
+
+    Subclasses should implement the `token_counter`, `token_limit`, and
+    `create_context` methods to provide specific context creation logic.
+
+    Attributes:
+        token_counter (BaseTokenCounter): A token counter instance responsible
+            for counting tokens in a message.
+        token_limit (int): The maximum number of tokens allowed in the
+            generated context.
+    """
+
+    @property
+    @abstractmethod
+    def token_counter(self) -> BaseTokenCounter:
+        pass
+
+    @property
+    @abstractmethod
+    def token_limit(self) -> int:
+        pass
+
+    @abstractmethod
+    def create_context(
+        self,
+        records: List[ContextRecord],
+    ) -> Tuple[List[OpenAIMessage], int]:
+        r"""An abstract method to create conversational context from the chat
+        history.
+
+        Constructs the context from provided records. The specifics of how this
+        is done and how the token count is managed should be provided by
+        subclasses implementing this method. The the output messages order
+        should keep same as the input order.
+
+        Args:
+            records (List[ContextRecord]): A list of context records from
+                which to generate the context.
+
+        Returns:
+            Tuple[List[OpenAIMessage], int]: A tuple containing the constructed
+                context in OpenAIMessage format and the total token count.
+        """
+        pass

camel/memories/context_creators/score_based.py

@@ -0,0 +1,130 @@
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+# Licensed under the Apache License, Version 2.0 (the “License”);
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an “AS IS” BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+from dataclasses import dataclass
+from typing import List, Tuple
+
+from camel.memories import ContextRecord
+from camel.memories.context_creators import BaseContextCreator
+from camel.messages import OpenAIMessage
+from camel.utils import BaseTokenCounter
+
+
+@dataclass(frozen=True)
+class _ContextUnit:
+    idx: int
+    record: ContextRecord
+    num_tokens: int
+
+
+class ScoreBasedContextCreator(BaseContextCreator):
+    r"""A default implementation of context creation strategy, which inherits
+    from :obj:`BaseContextCreator`.
+
+    This class provides a strategy to generate a conversational context from
+    a list of chat history records while ensuring the total token count of
+    the context does not exceed a specified limit. It prunes messages based
+    on their score if the total token count exceeds the limit.
+
+    Args:
+        token_counter (BaseTokenCounter): An instance responsible for counting
+            tokens in a message.
+        token_limit (int): The maximum number of tokens allowed in the
+            generated context.
+    """
+
+    def __init__(self, token_counter: BaseTokenCounter,
+                 token_limit: int) -> None:
+        self._token_counter = token_counter
+        self._token_limit = token_limit
+
+    @property
+    def token_counter(self) -> BaseTokenCounter:
+        return self._token_counter
+
+    @property
+    def token_limit(self) -> int:
+        return self._token_limit
+
+    def create_context(
+        self,
+        records: List[ContextRecord],
+    ) -> Tuple[List[OpenAIMessage], int]:
+        r"""Creates conversational context from chat history while respecting
+        token limits.
+
+        Constructs the context from provided records and ensures that the total
+        token count does not exceed the specified limit by pruning the least
+        score messages if necessary.
+
+        Args:
+            records (List[ContextRecord]): A list of message records from which
+                to generate the context.
+
+        Returns:
+            Tuple[List[OpenAIMessage], int]: A tuple containing the constructed
+                context in OpenAIMessage format and the total token count.
+
+        Raises:
+            RuntimeError: If it's impossible to create a valid context without
+                exceeding the token limit.
+        """
+        context_units = [
+            _ContextUnit(
+                idx,
+                record,
+                self.token_counter.count_tokens_from_messages(
+                    [record.memory_record.to_openai_message()]),
+            ) for idx, record in enumerate(records)
+        ]
+        # TODO: optimize the process, may give information back to memory
+
+        # If not exceed token limit, simply return
+        total_tokens = sum([unit.num_tokens for unit in context_units])
+        if total_tokens <= self.token_limit:
+            return self._create_output(context_units)
+
+        # Sort by score
+        context_units = sorted(context_units,
+                               key=lambda unit: unit.record.score)
+
+        # Remove least score messages until total token number is smaller
+        # than token limit
+        truncate_idx = None
+        for i, unit in enumerate(context_units):
+            if unit.record.score == 1:
+                raise RuntimeError(
+                    "Cannot create context: exceed token limit.", total_tokens)
+            total_tokens -= unit.num_tokens
+            if total_tokens <= self.token_limit:
+                truncate_idx = i
+                break
+        if truncate_idx is None:
+            raise RuntimeError("Cannot create context: exceed token limit.",
+                               total_tokens)
+        return self._create_output(context_units[truncate_idx + 1:])
+
+    def _create_output(
+            self, context_units: List[_ContextUnit]
+    ) -> Tuple[List[OpenAIMessage], int]:
+        r"""Helper method to generate output from context units.
+
+        This method converts the provided context units into a format suitable
+        for output, specifically a list of OpenAIMessages and an integer
+        representing the total token count.
+        """
+        context_units = sorted(context_units, key=lambda unit: unit.idx)
+        return [
+            unit.record.memory_record.to_openai_message()
+            for unit in context_units
+        ], sum([unit.num_tokens for unit in context_units])

camel/memories/records.py

@@ -0,0 +1,92 @@
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+# Licensed under the Apache License, Version 2.0 (the “License”);
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an “AS IS” BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+
+from dataclasses import asdict, dataclass, field
+from typing import Any, ClassVar, Dict
+from uuid import UUID, uuid4
+
+from camel.messages import BaseMessage, FunctionCallingMessage, OpenAIMessage
+from camel.types import OpenAIBackendRole
+
+
+@dataclass(frozen=True)
+class MemoryRecord:
+    r"""The basic message storing unit in the CAMEL memory system.
+
+    Attributes:
+        message (BaseMessage): The main content of the record.
+        role_at_backend (OpenAIBackendRole): An enumeration value representing
+            the role this message played at the OpenAI backend. Note that this
+            value is different from the :obj:`RoleType` used in the CAMEL role
+            playing system.
+        uuid (UUID, optional): A universally unique identifier for this record.
+            This is used to uniquely identify this record in the memory system.
+            If not given, it will be assigned with a random UUID.
+        extra_info (Dict[str, str], optional): A dictionary of additional
+            key-value pairs that provide more information. If not given, it
+            will be an empty `Dict`.
+    """
+    message: BaseMessage
+    role_at_backend: OpenAIBackendRole
+    uuid: UUID = field(default_factory=uuid4)
+    extra_info: Dict[str, str] = field(default_factory=dict)
+
+    _MESSAGE_TYPES: ClassVar[dict] = {
+        "BaseMessage": BaseMessage,
+        "FunctionCallingMessage": FunctionCallingMessage
+    }
+
+    @classmethod
+    def from_dict(cls, record_dict: Dict[str, Any]) -> "MemoryRecord":
+        r"""Reconstruct a :obj:`MemoryRecord` from the input dict.
+
+        Args:
+            record_dict(Dict[str, Any]): A dict generated by :meth:`to_dict`.
+        """
+        message_cls = cls._MESSAGE_TYPES[record_dict["message"]["__class__"]]
+        kwargs: Dict = record_dict["message"].copy()
+        kwargs.pop("__class__")
+        reconstructed_message = message_cls(**kwargs)
+        return cls(
+            uuid=UUID(record_dict["uuid"]),
+            message=reconstructed_message,
+            role_at_backend=record_dict["role_at_backend"],
+            extra_info=record_dict["extra_info"],
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        r"""Convert the :obj:`MemoryRecord` to a dict for serialization
+        purposes.
+        """
+        return {
+            "uuid": str(self.uuid),
+            "message": {
+                "__class__": self.message.__class__.__name__,
+                **asdict(self.message)
+            },
+            "role_at_backend": self.role_at_backend,
+            "extra_info": self.extra_info
+        }
+
+    def to_openai_message(self) -> OpenAIMessage:
+        r"""Converts the record to an :obj:`OpenAIMessage` object."""
+        return self.message.to_openai_message(self.role_at_backend)
+
+
+@dataclass(frozen=True)
+class ContextRecord:
+    r"""The result of memory retrieving.
+    """
+    memory_record: MemoryRecord
+    score: float

camel/messages/__init__.py

@@ -0,0 +1,38 @@
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+# Licensed under the Apache License, Version 2.0 (the “License”);
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an “AS IS” BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+from camel.types import (
+    ChatCompletionSystemMessageParam,
+    ChatCompletionAssistantMessageParam,
+    ChatCompletionUserMessageParam,
+    ChatCompletionFunctionMessageParam,
+    ChatCompletionMessageParam,
+)
+
+OpenAISystemMessage = ChatCompletionSystemMessageParam
+OpenAIAssistantMessage = ChatCompletionAssistantMessageParam
+OpenAIUserMessage = ChatCompletionUserMessageParam
+OpenAIFunctionMessage = ChatCompletionFunctionMessageParam
+OpenAIMessage = ChatCompletionMessageParam
+
+from .base import BaseMessage  # noqa: E402
+from .func_message import FunctionCallingMessage  # noqa: E402
+
+__all__ = [
+    'OpenAISystemMessage',
+    'OpenAIAssistantMessage',
+    'OpenAIUserMessage',
+    'OpenAIMessage',
+    'BaseMessage',
+    'FunctionCallingMessage',
+]

camel/messages/base.py

@@ -0,0 +1,223 @@
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+# Licensed under the Apache License, Version 2.0 (the “License”);
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an “AS IS” BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from camel.messages import (
+    OpenAIAssistantMessage,
+    OpenAIMessage,
+    OpenAISystemMessage,
+    OpenAIUserMessage,
+)
+from camel.prompts import CodePrompt, TextPrompt
+from camel.types import OpenAIBackendRole, RoleType
+
+
+@dataclass
+class BaseMessage:
+    r"""Base class for message objects used in CAMEL chat system.
+
+    Args:
+        role_name (str): The name of the user or assistant role.
+        role_type (RoleType): The type of role, either
+            :obj:`RoleType.ASSISTANT` or :obj:`RoleType.USER`.
+        meta_dict (Optional[Dict[str, str]]): Additional metadata dictionary
+            for the message.
+        content (str): The content of the message.
+    """
+    role_name: str
+    role_type: RoleType
+    meta_dict: Optional[Dict[str, str]]
+    content: str
+
+    @classmethod
+    def make_user_message(
+            cls, role_name: str, content: str,
+            meta_dict: Optional[Dict[str, str]] = None) -> 'BaseMessage':
+        return cls(role_name, RoleType.USER, meta_dict, content)
+
+    @classmethod
+    def make_assistant_message(
+            cls, role_name: str, content: str,
+            meta_dict: Optional[Dict[str, str]] = None) -> 'BaseMessage':
+        return cls(role_name, RoleType.ASSISTANT, meta_dict, content)
+
+    def create_new_instance(self, content: str) -> "BaseMessage":
+        r"""Create a new instance of the :obj:`BaseMessage` with updated
+        content.
+
+        Args:
+            content (str): The new content value.
+
+        Returns:
+            BaseMessage: The new instance of :obj:`BaseMessage`.
+        """
+        return self.__class__(role_name=self.role_name,
+                              role_type=self.role_type,
+                              meta_dict=self.meta_dict, content=content)
+
+    def __add__(self, other: Any) -> Union["BaseMessage", Any]:
+        r"""Addition operator override for :obj:`BaseMessage`.
+
+        Args:
+            other (Any): The value to be added with.
+
+        Returns:
+            Union[BaseMessage, Any]: The result of the addition.
+        """
+        if isinstance(other, BaseMessage):
+            combined_content = self.content.__add__(other.content)
+        elif isinstance(other, str):
+            combined_content = self.content.__add__(other)
+        else:
+            raise TypeError(
+                f"Unsupported operand type(s) for +: '{type(self)}' and "
+                f"'{type(other)}'")
+        return self.create_new_instance(combined_content)
+
+    def __mul__(self, other: Any) -> Union["BaseMessage", Any]:
+        r"""Multiplication operator override for :obj:`BaseMessage`.
+
+        Args:
+            other (Any): The value to be multiplied with.
+
+        Returns:
+            Union[BaseMessage, Any]: The result of the multiplication.
+        """
+        if isinstance(other, int):
+            multiplied_content = self.content.__mul__(other)
+            return self.create_new_instance(multiplied_content)
+        else:
+            raise TypeError(
+                f"Unsupported operand type(s) for *: '{type(self)}' and "
+                f"'{type(other)}'")
+
+    def __len__(self) -> int:
+        r"""Length operator override for :obj:`BaseMessage`.
+
+        Returns:
+            int: The length of the content.
+        """
+        return len(self.content)
+
+    def __contains__(self, item: str) -> bool:
+        r"""Contains operator override for :obj:`BaseMessage`.
+
+        Args:
+            item (str): The item to check for containment.
+
+        Returns:
+            bool: :obj:`True` if the item is contained in the content,
+                :obj:`False` otherwise.
+        """
+        return item in self.content
+
+    def extract_text_and_code_prompts(
+            self) -> Tuple[List[TextPrompt], List[CodePrompt]]:
+        r"""Extract text and code prompts from the message content.
+
+        Returns:
+            Tuple[List[TextPrompt], List[CodePrompt]]: A tuple containing a
+                list of text prompts and a list of code prompts extracted
+                from the content.
+        """
+        text_prompts: List[TextPrompt] = []
+        code_prompts: List[CodePrompt] = []
+
+        lines = self.content.split("\n")
+        idx = 0
+        start_idx = 0
+        while idx < len(lines):
+            while idx < len(lines) and (
+                    not lines[idx].lstrip().startswith("```")):
+                idx += 1
+            text = "\n".join(lines[start_idx:idx]).strip()
+            text_prompts.append(TextPrompt(text))
+
+            if idx >= len(lines):
+                break
+
+            code_type = lines[idx].strip()[3:].strip()
+            idx += 1
+            start_idx = idx
+            while not lines[idx].lstrip().startswith("```"):
+                idx += 1
+            code = "\n".join(lines[start_idx:idx]).strip()
+            code_prompts.append(CodePrompt(code, code_type=code_type))
+
+            idx += 1
+            start_idx = idx
+
+        return text_prompts, code_prompts
+
+    def to_openai_message(
+        self,
+        role_at_backend: OpenAIBackendRole,
+    ) -> OpenAIMessage:
+        r"""Converts the message to an :obj:`OpenAIMessage` object.
+
+        Args:
+            role_at_backend (OpenAIBackendRole): The role of the message in
+                OpenAI chat system.
+
+        Returns:
+            OpenAIMessage: The converted :obj:`OpenAIMessage` object.
+        """
+        if role_at_backend == OpenAIBackendRole.SYSTEM:
+            return self.to_openai_system_message()
+        elif role_at_backend == OpenAIBackendRole.USER:
+            return self.to_openai_user_message()
+        elif role_at_backend == OpenAIBackendRole.ASSISTANT:
+            return self.to_openai_assistant_message()
+        else:
+            raise ValueError(f"Unsupported role: {role_at_backend}.")
+
+    def to_openai_system_message(self) -> OpenAISystemMessage:
+        r"""Converts the message to an :obj:`OpenAISystemMessage` object.
+
+        Returns:
+            OpenAISystemMessage: The converted :obj:`OpenAISystemMessage`
+                object.
+        """
+        return {"role": "system", "content": self.content}
+
+    def to_openai_user_message(self) -> OpenAIUserMessage:
+        r"""Converts the message to an :obj:`OpenAIUserMessage` object.
+
+        Returns:
+            OpenAIUserMessage: The converted :obj:`OpenAIUserMessage` object.
+        """
+        return {"role": "user", "content": self.content}
+
+    def to_openai_assistant_message(self) -> OpenAIAssistantMessage:
+        r"""Converts the message to an :obj:`OpenAIAssistantMessage` object.
+
+        Returns:
+            OpenAIAssistantMessage: The converted :obj:`OpenAIAssistantMessage`
+                object.
+        """
+        return {"role": "assistant", "content": self.content}
+
+    def to_dict(self) -> Dict:
+        r"""Converts the message to a dictionary.
+
+        Returns:
+            dict: The converted dictionary.
+        """
+        return {
+            "role_name": self.role_name,
+            "role_type": self.role_type.name,
+            **(self.meta_dict or {}),
+            "content": self.content,
+        }