camel-ai 0.1.1__py3-none-any.whl

camel/prompts/prompt_templates.py

@@ -0,0 +1,117 @@
+# =========== 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. ===========
+import warnings
+from typing import Any, Optional
+
+from camel.prompts import TaskPromptTemplateDict, TextPrompt
+from camel.types import RoleType, TaskType
+
+
+class PromptTemplateGenerator:
+    r"""A class for generating prompt templates for tasks.
+
+    Args:
+        task_prompt_template_dict (TaskPromptTemplateDict, optional):
+            A dictionary of task prompt templates for each task type. If not
+            provided, an empty dictionary is used as default.
+    """
+
+    def __init__(
+        self,
+        task_prompt_template_dict: Optional[TaskPromptTemplateDict] = None,
+    ) -> None:
+        self.task_prompt_template_dict = (task_prompt_template_dict
+                                          or TaskPromptTemplateDict())
+
+    def get_prompt_from_key(self, task_type: TaskType, key: Any) -> TextPrompt:
+        r"""Generates a text prompt using the specified :obj:`task_type` and
+        :obj:`key`.
+
+        Args:
+            task_type (TaskType): The type of task.
+            key (Any): The key used to generate the prompt.
+
+        Returns:
+            TextPrompt: The generated text prompt.
+
+        Raises:
+            KeyError: If failed to generate prompt using the specified
+                :obj:`task_type` and :obj:`key`.
+        """
+        try:
+            return self.task_prompt_template_dict[task_type][key]
+
+        except KeyError:
+            raise KeyError("Failed to get generate prompt template for "
+                           f"task: {task_type.value} from key: {key}.")
+
+    def get_system_prompt(
+        self,
+        task_type: TaskType,
+        role_type: RoleType,
+    ) -> TextPrompt:
+        r"""Generates a text prompt for the system role, using the specified
+        :obj:`task_type` and :obj:`role_type`.
+
+        Args:
+            task_type (TaskType): The type of task.
+            role_type (RoleType): The type of role, either "USER" or
+                "ASSISTANT".
+
+        Returns:
+            TextPrompt: The generated text prompt.
+
+        Raises:
+            KeyError: If failed to generate prompt using the specified
+                :obj:`task_type` and :obj:`role_type`.
+        """
+        try:
+            return self.get_prompt_from_key(task_type, role_type)
+
+        except KeyError:
+            prompt = "You are a helpful assistant."
+
+            warnings.warn("Failed to get system prompt template for "
+                          f"task: {task_type.value}, role: {role_type.value}. "
+                          f"Set template to: {prompt}")
+
+        return TextPrompt(prompt)
+
+    def get_generate_tasks_prompt(
+        self,
+        task_type: TaskType,
+    ) -> TextPrompt:
+        r"""Gets the prompt for generating tasks for a given task type.
+
+        Args:
+            task_type (TaskType): The type of the task.
+
+        Returns:
+            TextPrompt: The generated prompt for generating tasks.
+        """
+        return self.get_prompt_from_key(task_type, "generate_tasks")
+
+    def get_task_specify_prompt(
+        self,
+        task_type: TaskType,
+    ) -> TextPrompt:
+        r"""Gets the prompt for specifying a task for a given task type.
+
+        Args:
+            task_type (TaskType): The type of the task.
+
+        Returns:
+            TextPrompt: The generated prompt for specifying a task.
+        """
+        return self.get_prompt_from_key(task_type, "task_specify_prompt")

camel/prompts/role_description_prompt_template.py

@@ -0,0 +1,53 @@
+# =========== 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 Any
+
+from camel.prompts import AISocietyPromptTemplateDict, TextPrompt
+from camel.types import RoleType
+
+
+# flake8: noqa :E501
+class RoleDescriptionPromptTemplateDict(AISocietyPromptTemplateDict):
+    r"""A dictionary containing :obj:`TextPrompt` used in the `role description`
+    task.
+
+    Attributes:
+        ROLE_DESCRIPTION_PROMPT (TextPrompt): A default prompt to
+            describe the role descriptions.
+        ASSISTANT_PROMPT (TextPrompt): A system prompt for the AI assistant
+            that outlines the rules of the conversation and provides
+            instructions for completing tasks.
+        USER_PROMPT (TextPrompt): A system prompt for the AI user that
+            outlines the rules of the conversation and provides instructions
+            for giving instructions to the AI assistant.
+    """
+    ROLE_DESCRIPTION_PROMPT = TextPrompt("""===== ROLES WITH DESCRIPTION =====
+{user_role} and {assistant_role} are collaborating to complete a task: {task}.
+Competencies, characteristics, duties and workflows of {user_role} to complete the task: {user_description}
+{assistant_role}'s competencies, characteristics, duties and workflows to complete the task: {assistant_description}
+""")
+
+    ASSISTANT_PROMPT = TextPrompt(ROLE_DESCRIPTION_PROMPT +
+                                  AISocietyPromptTemplateDict.ASSISTANT_PROMPT)
+
+    USER_PROMPT = TextPrompt(ROLE_DESCRIPTION_PROMPT +
+                             AISocietyPromptTemplateDict.USER_PROMPT)
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.update({
+            "role_description": self.ROLE_DESCRIPTION_PROMPT,
+            RoleType.ASSISTANT: self.ASSISTANT_PROMPT,
+            RoleType.USER: self.USER_PROMPT,
+        })

camel/prompts/solution_extraction.py

@@ -0,0 +1,44 @@
+# =========== 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 Any
+
+from camel.prompts import TextPrompt, TextPromptDict
+from camel.types import RoleType
+
+
+# flake8: noqa
+class SolutionExtractionPromptTemplateDict(TextPromptDict):
+    r"""A dictionary containing :obj:`TextPrompt` used in the `SolutionExtraction`
+    task.
+
+    Attributes:
+        ASSISTANT_PROMPT (TextPrompt): A system prompt for the AI assistant
+            that outlines the rules of the conversation and provides
+            instructions for completing tasks.
+    """
+    ASSISTANT_PROMPT = TextPrompt(
+        """You are an experienced solution extracting agent. 
+Your task is to extract full and complete solutions by looking at the conversation between a user and an assistant with particular specializations. 
+You should present me with a final and detailed solution purely based on the conversation. 
+You should present the solution as if its yours. 
+Use present tense and as if you are the one presenting the solution. 
+You should not miss any necessary details or examples.
+Keep all provided explanations and codes provided throughout the conversation. 
+Remember your task is not to summarize rather to extract the full solution.""")
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.update({
+            RoleType.ASSISTANT: self.ASSISTANT_PROMPT,
+        })

camel/prompts/task_prompt_template.py

@@ -0,0 +1,56 @@
+# =========== 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 Any, Dict
+
+from camel.prompts import (
+    AISocietyPromptTemplateDict,
+    CodePromptTemplateDict,
+    EvaluationPromptTemplateDict,
+    MisalignmentPromptTemplateDict,
+    RoleDescriptionPromptTemplateDict,
+    SolutionExtractionPromptTemplateDict,
+    TextPromptDict,
+    TranslationPromptTemplateDict,
+)
+from camel.types import TaskType
+
+
+class TaskPromptTemplateDict(Dict[Any, TextPromptDict]):
+    r"""A dictionary (:obj:`Dict[Any, TextPromptDict]`) of task prompt
+    templates keyed by task type. This dictionary is used to map from
+    a task type to its corresponding prompt template dictionary.
+
+    Args:
+        *args: Positional arguments passed to the :obj:`dict` constructor.
+        **kwargs: Keyword arguments passed to the :obj:`dict` constructor.
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.update({
+            TaskType.AI_SOCIETY:
+            AISocietyPromptTemplateDict(),
+            TaskType.CODE:
+            CodePromptTemplateDict(),
+            TaskType.MISALIGNMENT:
+            MisalignmentPromptTemplateDict(),
+            TaskType.TRANSLATION:
+            TranslationPromptTemplateDict(),
+            TaskType.EVALUATION:
+            EvaluationPromptTemplateDict(),
+            TaskType.SOLUTION_EXTRACTION:
+            SolutionExtractionPromptTemplateDict(),
+            TaskType.ROLE_DESCRIPTION:
+            RoleDescriptionPromptTemplateDict(),
+        })

camel/prompts/translation.py

@@ -0,0 +1,42 @@
+# =========== 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 Any
+
+from camel.prompts import TextPrompt, TextPromptDict
+from camel.types import RoleType
+
+
+# flake8: noqa :E501
+class TranslationPromptTemplateDict(TextPromptDict):
+    r"""A dictionary containing :obj:`TextPrompt` used in the `Translation`
+    task.
+
+    Attributes:
+        ASSISTANT_PROMPT (TextPrompt): A system prompt for the AI assistant
+            that outlines the rules of the conversation and provides
+            instructions for completing tasks.
+    """
+    ASSISTANT_PROMPT = TextPrompt(
+        """You are an expert English to {language} translator.
+Your sole purpose is to accurately translate any text presented to you from English to {language}.
+Please provide the {language} translation for the given text.
+If you are presented with an empty string, simply return an empty string as the translation.
+Only text in between ```TEXT``` should not be translated.
+Do not provide any explanation. Just provide a translation.""")
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.update({
+            RoleType.ASSISTANT: self.ASSISTANT_PROMPT,
+        })

camel/responses/__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 .agent_responses import ChatAgentResponse
+
+__all__ = [
+    'ChatAgentResponse',
+]

camel/responses/agent_responses.py

@@ -0,0 +1,42 @@
+# =========== 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
+
+from camel.messages import BaseMessage
+
+
+@dataclass(frozen=True)
+class ChatAgentResponse:
+    r"""Response of a ChatAgent.
+
+    Attributes:
+        msgs (List[BaseMessage]): A list of zero, one or several messages.
+            If the list is empty, there is some error in message generation.
+            If the list has one message, this is normal mode.
+            If the list has several messages, this is the critic mode.
+        terminated (bool): A boolean indicating whether the agent decided
+            to terminate the chat session.
+        info (Dict[str, Any]): Extra information about the chat message.
+    """
+    msgs: List[BaseMessage]
+    terminated: bool
+    info: Dict[str, Any]
+
+    @property
+    def msg(self):
+        if len(self.msgs) != 1:
+            raise RuntimeError("Property msg is only available "
+                               "for a single message in msgs.")
+        return self.msgs[0]

camel/societies/__init__.py

@@ -0,0 +1,20 @@
+# =========== 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 .role_playing import RolePlaying
+from .babyagi_playing import BabyAGI
+
+__all__ = [
+    'RolePlaying',
+    'BabyAGI',
+]

camel/societies/babyagi_playing.py

@@ -0,0 +1,254 @@
+# =========== 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 collections import deque
+from typing import Dict, List, Optional
+
+from camel.agents import (
+    ChatAgent,
+    TaskCreationAgent,
+    TaskPrioritizationAgent,
+    TaskSpecifyAgent,
+)
+from camel.agents.chat_agent import ChatAgentResponse
+from camel.generators import SystemMessageGenerator
+from camel.messages import BaseMessage
+from camel.prompts import TextPrompt
+from camel.types import RoleType, TaskType
+
+
+class BabyAGI:
+    r"""The BabyAGI Agent adapted from `"Task-driven Autonomous Agent"
+    <https://github.com/yoheinakajima/babyagi>`_.
+
+    Args:
+        assistant_role_name (str): The name of the role played by the
+            assistant.
+        user_role_name (str): The name of the role played by the user.
+        task_prompt (str, optional): A prompt for the task to be performed.
+            (default: :obj:`""`)
+        task_type (TaskType, optional): The type of task to perform.
+            (default: :obj:`TaskType.AI_SOCIETY`)
+        max_task_history (int): The maximum number of previous tasks
+            information to include in the task agent.
+            (default: :obj:10)
+        assistant_agent_kwargs (Dict, optional): Additional arguments to pass
+            to the assistant agent. (default: :obj:`None`)
+        task_specify_agent_kwargs (Dict, optional): Additional arguments to
+            pass to the task specify agent. (default: :obj:`None`)
+        task_creation_agent_kwargs (Dict, optional): Additional arguments to
+            pass to the task creation agent. (default: :obj:`None`)
+        task_prioritization_agent_kwargs (Dict, optional): Additional arguments
+            to pass to the task prioritization agent. (default: :obj:`None`)
+        sys_msg_generator_kwargs (Dict, optional): Additional arguments to
+            pass to the system message generator. (default: :obj:`None`)
+        extend_task_specify_meta_dict (Dict, optional): A dict to extend the
+            task specify meta dict with. (default: :obj:`None`)
+        output_language (str, optional): The language to be output by the
+            agents. (default: :obj:`None`)
+        message_window_size (int, optional): The maximum number of previous
+            messages to include in the context window. If `None`, no windowing
+            is performed. (default: :obj:`None`)
+    """
+
+    def __init__(
+        self,
+        assistant_role_name: str,
+        user_role_name: str,
+        task_prompt: str = "",
+        task_type: TaskType = TaskType.AI_SOCIETY,
+        max_task_history: int = 10,
+        assistant_agent_kwargs: Optional[Dict] = None,
+        task_specify_agent_kwargs: Optional[Dict] = None,
+        task_creation_agent_kwargs: Optional[Dict] = None,
+        task_prioritization_agent_kwargs: Optional[Dict] = None,
+        sys_msg_generator_kwargs: Optional[Dict] = None,
+        extend_task_specify_meta_dict: Optional[Dict] = None,
+        output_language: Optional[str] = None,
+        message_window_size: Optional[int] = None,
+    ) -> None:
+        self.task_type = task_type
+        self.task_prompt = task_prompt
+        self.specified_task_prompt: TextPrompt
+        self.init_specified_task_prompt(assistant_role_name, user_role_name,
+                                        task_specify_agent_kwargs,
+                                        extend_task_specify_meta_dict,
+                                        output_language)
+
+        sys_msg_generator = SystemMessageGenerator(
+            task_type=self.task_type, **(sys_msg_generator_kwargs or {}))
+
+        init_assistant_sys_msg = sys_msg_generator.from_dicts(
+            meta_dicts=[
+                dict(
+                    assistant_role=assistant_role_name,
+                    user_role=user_role_name,
+                    task=self.specified_task_prompt,
+                )
+            ],
+            role_tuples=[
+                (assistant_role_name, RoleType.ASSISTANT),
+            ],
+        )
+
+        self.assistant_agent: ChatAgent
+        self.assistant_sys_msg: BaseMessage
+        self.task_creation_agent: TaskCreationAgent
+        self.task_prioritization_agent: TaskPrioritizationAgent
+        self.init_agents(init_assistant_sys_msg[0], assistant_agent_kwargs,
+                         task_creation_agent_kwargs,
+                         task_prioritization_agent_kwargs, output_language,
+                         message_window_size)
+
+        self.subtasks: deque = deque([])
+        self.solved_subtasks: List[str] = []
+        self.MAX_TASK_HISTORY = max_task_history
+
+    def init_specified_task_prompt(
+            self, assistant_role_name: str, user_role_name: str,
+            task_specify_agent_kwargs: Optional[Dict],
+            extend_task_specify_meta_dict: Optional[Dict],
+            output_language: Optional[str]):
+        r"""Use a task specify agent to generate a specified task prompt.
+        Generated specified task prompt will be used to replace original
+        task prompt. If there is no task specify agent, specified task
+        prompt will not be generated.
+
+        Args:
+            assistant_role_name (str): The name of the role played by the
+                assistant.
+            user_role_name (str): The name of the role played by the user.
+            task_specify_agent_kwargs (Dict, optional): Additional arguments
+                to pass to the task specify agent.
+            extend_task_specify_meta_dict (Dict, optional): A dict to extend
+                the task specify meta dict with.
+            output_language (str, optional): The language to be output by the
+                agents.
+        """
+        task_specify_meta_dict = dict()
+        if self.task_type in [TaskType.AI_SOCIETY, TaskType.MISALIGNMENT]:
+            task_specify_meta_dict.update(
+                dict(assistant_role=assistant_role_name,
+                     user_role=user_role_name))
+        task_specify_meta_dict.update(extend_task_specify_meta_dict or {})
+        task_specify_agent = TaskSpecifyAgent(
+            task_type=self.task_type,
+            output_language=output_language,
+            **(task_specify_agent_kwargs or {}),
+        )
+        self.specified_task_prompt = task_specify_agent.run(
+            self.task_prompt,
+            meta_dict=task_specify_meta_dict,
+        )
+
+    def init_agents(self, init_assistant_sys_msg: BaseMessage,
+                    assistant_agent_kwargs: Optional[Dict],
+                    task_creation_agent_kwargs: Optional[Dict],
+                    task_prioritization_agent_kwargs: Optional[Dict],
+                    output_language: Optional[str],
+                    message_window_size: Optional[int] = None):
+        r"""Initialize assistant and user agents with their system messages.
+
+        Args:
+            init_assistant_sys_msg (BaseMessage): Assistant agent's initial
+                system message.
+            assistant_agent_kwargs (Dict, optional): Additional arguments to
+                pass to the assistant agent.
+            task_creation_agent_kwargs (Dict, optional): Additional arguments
+                to pass to the task creation agent.
+            task_prioritization_agent_kwargs (Dict, optional): Additional
+                arguments to pass to the task prioritization agent.
+            output_language (str, optional): The language to be output by the
+                agents.
+            message_window_size (int, optional): The maximum number of previous
+                messages to include in the context window. If `None`, no
+                windowing is performed. (default: :obj:`None`)
+        """
+        self.assistant_agent = ChatAgent(
+            init_assistant_sys_msg,
+            output_language=output_language,
+            message_window_size=message_window_size,
+            **(assistant_agent_kwargs or {}),
+        )
+        self.assistant_sys_msg = self.assistant_agent.system_message
+        self.assistant_agent.reset()
+
+        self.task_creation_agent = TaskCreationAgent(
+            objective=self.specified_task_prompt,
+            role_name=self.assistant_sys_msg.role_name,
+            output_language=output_language,
+            message_window_size=message_window_size,
+            **(task_creation_agent_kwargs or {}),
+        )
+        self.task_creation_agent.reset()
+
+        self.task_prioritization_agent = TaskPrioritizationAgent(
+            objective=self.specified_task_prompt,
+            output_language=output_language,
+            message_window_size=message_window_size,
+            **(task_prioritization_agent_kwargs or {}),
+        )
+        self.task_prioritization_agent.reset()
+
+    def step(self) -> ChatAgentResponse:
+        r"""BabyAGI agent would pull the first task from the task list,
+        complete the task based on the context, then creates new tasks and
+        re-prioritizes the task list based on the objective and the result of
+        the previous task. It returns assistant message.
+
+        Returns:
+            ChatAgentResponse: it contains the resulting assistant message,
+            whether the assistant agent terminated the conversation,
+            and any additional assistant information.
+
+        """
+        if not self.subtasks:
+            new_subtask_list = self.task_creation_agent.run(task_list=[])
+            prioritized_subtask_list = self.task_prioritization_agent.run(
+                new_subtask_list)
+            self.subtasks = deque(prioritized_subtask_list)
+
+        task_name = self.subtasks.popleft()
+        assistant_msg_msg = BaseMessage.make_user_message(
+            role_name=self.assistant_sys_msg.role_name, content=f"{task_name}")
+
+        assistant_response = self.assistant_agent.step(assistant_msg_msg)
+        assistant_msg = assistant_response.msgs[0]
+        self.assistant_agent.record_message(assistant_msg)
+        self.task_creation_agent.record_message(assistant_msg)
+        self.task_prioritization_agent.record_message(assistant_msg)
+
+        self.solved_subtasks.append(task_name)
+        past_tasks = self.solved_subtasks + list(self.subtasks)
+
+        new_subtask_list = self.task_creation_agent.run(
+            task_list=past_tasks[-self.MAX_TASK_HISTORY:])
+
+        if new_subtask_list:
+            self.subtasks.extend(new_subtask_list)
+            prioritized_subtask_list = self.task_prioritization_agent.run(
+                task_list=list(self.subtasks)[-self.MAX_TASK_HISTORY:])
+            self.subtasks = deque(prioritized_subtask_list)
+        else:
+            print("no new tasks")
+        assistant_response.info['task_name'] = task_name
+        assistant_response.info['subtasks'] = list(self.subtasks)
+        if not self.subtasks:
+            terminated = True
+            assistant_response.info[
+                'termination_reasons'] = "All tasks are solved"
+            return ChatAgentResponse([assistant_msg], terminated,
+                                     assistant_response.info)
+        return ChatAgentResponse([assistant_msg],
+                                 assistant_response.terminated,
+                                 assistant_response.info)