camel-ai 0.1.5.6__py3-none-any.whl → 0.1.6.1__py3-none-any.whl

camel/workforce/role_playing_node.py

@@ -0,0 +1,168 @@
+# =========== 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 __future__ import annotations
+
+from typing import Dict, List, Optional
+
+from colorama import Fore, Style
+
+from camel.agents.chat_agent import ChatAgent, FunctionCallingRecord
+from camel.messages.base import BaseMessage
+from camel.societies import RolePlaying
+from camel.tasks.task import Task, TaskState
+from camel.utils import print_text_animated
+from camel.workforce.utils import parse_task_result_resp
+from camel.workforce.worker_node import WorkerNode
+from camel.workforce.workforce_prompt import (
+    ROLEPLAY_PROCESS_TASK_PROMPT,
+    ROLEPLAY_SUMMERIZE_PROMPT,
+)
+
+
+class RolePlayingNode(WorkerNode):
+    r"""A worker node that contains a role playing.
+
+    Args:
+        description (str): Description of the node.
+        assistant_role_name (str): The role name of the assistant agent.
+        user_role_name (str): The role name of the user agent.
+        assistant_agent_kwargs (Optional[Dict], optional): The keyword
+            arguments to initialize the assistant agent in the role playing,
+            like the model name, etc. Defaults to None.
+        user_agent_kwargs (Optional[Dict], optional): The keyword arguments to
+            initialize the user agent in the role playing, like the model name,
+            etc. Defaults to None.
+        chat_turn_limit (int, optional): The maximum number of chat turns in
+            the role playing. Defaults to 3.
+    """
+
+    def __init__(
+        self,
+        description: str,
+        assistant_role_name: str,
+        user_role_name: str,
+        assistant_agent_kwargs: Optional[Dict] = None,
+        user_agent_kwargs: Optional[Dict] = None,
+        chat_turn_limit: int = 3,
+    ) -> None:
+        super().__init__(description)
+        sys_message = BaseMessage.make_assistant_message(
+            role_name="Summarizer",
+            content="Good at summarizing the results of the chat logs",
+        )
+        self.summerize_agent = ChatAgent(sys_message)
+        self.chat_turn_limit = chat_turn_limit
+        self.assistant_role_name = assistant_role_name
+        self.user_role_name = user_role_name
+        self.assistant_agent_kwargs = assistant_agent_kwargs
+        self.user_agent_kwargs = user_agent_kwargs
+
+    async def _process_task(
+        self, task: Task, dependencies: List[Task]
+    ) -> TaskState:
+        r"""Processes a task leveraging its dependencies through role-playing.
+
+        This method orchestrates a role-playing session between an AI
+        assistant and an AI user to process a given task. It initiates with a
+        generated prompt based on the task and its dependencies, conducts a
+        dialogue up to a specified chat turn limit, and then summarizes the
+        dialogue to determine the task's outcome.
+
+        Args:
+            task (Task): The task object to be processed, containing necessary
+                details like content and type.
+            dependencies (List[Task]): A list of task objects that the current
+                task depends on.
+
+        Returns:
+            TaskState: `TaskState.DONE` if processed successfully, otherwise
+                `TaskState.FAILED`.
+        """
+        try:
+            dependency_tasks_info = self._get_dep_tasks_info(dependencies)
+            prompt = ROLEPLAY_PROCESS_TASK_PROMPT.format(
+                content=task.content,
+                type=task.type,
+                dependency_task_info=dependency_tasks_info,
+            )
+            role_play_session = RolePlaying(
+                assistant_role_name=self.assistant_role_name,
+                user_role_name=self.user_role_name,
+                assistant_agent_kwargs=self.assistant_agent_kwargs,
+                user_agent_kwargs=self.user_agent_kwargs,
+                task_prompt=prompt,
+                with_task_specify=False,
+            )
+            n = 0
+            input_msg = role_play_session.init_chat()
+            chat_history = []
+            while n < self.chat_turn_limit:
+                n += 1
+                assistant_response, user_response = role_play_session.step(
+                    input_msg
+                )
+
+                if assistant_response.terminated:
+                    reason = assistant_response.info['termination_reasons']
+                    print(
+                        Fore.GREEN + f"AI Assistant terminated. Reason: "
+                        f"{reason}. "
+                    )
+                    break
+                if user_response.terminated:
+                    reason = user_response.info['termination_reasons']
+                    print(
+                        Fore.GREEN + f"AI User terminated. Reason: {reason}."
+                    )
+                    break
+                print_text_animated(
+                    Fore.BLUE + f"AI User:\n\n{user_response.msg.content}\n",
+                    delay=0.005,
+                )
+                chat_history.append(f"AI User: {user_response.msg.content}")
+
+                print_text_animated(Fore.GREEN + "AI Assistant:", delay=0.005)
+                tool_calls: List[FunctionCallingRecord] = (
+                    assistant_response.info['tool_calls']
+                )
+                for func_record in tool_calls:
+                    print_text_animated(f"{func_record}", delay=0.005)
+                print_text_animated(
+                    f"{assistant_response.msg.content}\n", delay=0.005
+                )
+                chat_history.append(
+                    f"AI Assistant: {assistant_response.msg.content}"
+                )
+
+                if "CAMEL_TASK_DONE" in user_response.msg.content:
+                    break
+
+                input_msg = assistant_response.msg
+
+            chat_history_str = "\n".join(chat_history)
+            prompt = ROLEPLAY_SUMMERIZE_PROMPT.format(
+                content=task.content,
+                type=task.type,
+                chat_history=chat_history_str,
+            )
+            req = BaseMessage.make_user_message(
+                role_name="User",
+                content=prompt,
+            )
+            response = self.summerize_agent.step(req)
+            task.result = parse_task_result_resp(response.msg.content)
+            print(Style.RESET_ALL + 'Task result:', task.result, '\n')
+            return TaskState.DONE
+        except Exception:
+            return TaskState.FAILED

camel/workforce/single_agent_node.py

@@ -0,0 +1,77 @@
+# =========== 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 __future__ import annotations
+
+from typing import List
+
+from camel.agents.base import BaseAgent
+from camel.messages.base import BaseMessage
+from camel.tasks.task import Task, TaskState
+from camel.workforce.utils import parse_task_result_resp
+from camel.workforce.worker_node import WorkerNode
+from camel.workforce.workforce_prompt import PROCESS_TASK_PROMPT
+
+
+class SingleAgentNode(WorkerNode):
+    r"""A worker node that consists of a single agent.
+
+    Args:
+        description (str): Description of the node.
+        worker (BaseAgent): Worker of the node. A single agent.
+    """
+
+    def __init__(
+        self,
+        description: str,
+        worker: BaseAgent,
+    ) -> None:
+        super().__init__(description)
+        self.worker = worker
+
+    async def _process_task(
+        self, task: Task, dependencies: List[Task]
+    ) -> TaskState:
+        r"""Processes a task with its dependencies.
+
+        This method asynchronously processes a given task, considering its
+        dependencies, by sending a generated prompt to a worker. It updates
+        the task's result based on the agent's response.
+
+        Args:
+            task (Task): The task to process, which includes necessary details
+                like content and type.
+            dependencies (List[Task]): Tasks that the given task depends on.
+
+        Returns:
+            TaskState: `TaskState.DONE` if processed successfully, otherwise
+                `TaskState.FAILED`.
+        """
+        try:
+            dependency_tasks_info = self._get_dep_tasks_info(dependencies)
+            prompt = PROCESS_TASK_PROMPT.format(
+                content=task.content,
+                type=task.type,
+                dependency_task_info=dependency_tasks_info,
+            )
+            req = BaseMessage.make_user_message(
+                role_name="User",
+                content=prompt,
+            )
+            response = self.worker.step(req)
+            # print("info['tool_calls']:", response.info['tool_calls'])
+            task.result = parse_task_result_resp(response.msg.content)
+            print('Task result:', task.result, '\n')
+            return TaskState.DONE
+        except Exception:
+            return TaskState.FAILED

camel/workforce/task_channel.py

@@ -0,0 +1,173 @@
+# =========== 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 asyncio
+from enum import Enum
+from typing import Dict, List, Optional
+
+from camel.tasks import Task
+
+
+class PacketStatus(Enum):
+    r"""The status of a packet. The packet can be in one of the following
+    states:
+    - ``SENT``: The packet has been sent to a worker.
+    - ``RETURNED``: The packet has been returned by the worker, meaning that
+            the status of the task inside has been updated.
+    - ``ARCHIVED``: The packet has been archived, meaning that the content of
+            the task inside will not be changed. The task is considered
+            as a dependency.
+    """
+
+    SENT = "SENT"
+    RETURNED = "RETURNED"
+    ARCHIVED = "ARCHIVED"
+
+
+class Packet:
+    r"""The basic element inside the channel. A task is wrapped inside a
+    packet. The packet will contain the task, along with the task's assignee,
+    and the task's status.
+
+    Args:
+        task (Task): The task that is wrapped inside the packet.
+        publisher_id (str): The ID of the workforce that published the task.
+        assignee_id (str): The ID of the workforce that is assigned
+            to the task. Defaults to None, meaning that the task is posted as
+            a dependency in the channel.
+
+    Attributes:
+        task (Task): The task that is wrapped inside the packet.
+        publisher_id (str): The ID of the workforce that published the task.
+        assignee_id (Optional[str], optional): The ID of the workforce that is
+            assigned to the task. Would be None if the task is a dependency.
+            Defaults to None.
+        status (PacketStatus): The status of the task.
+    """
+
+    def __init__(
+        self,
+        task: Task,
+        publisher_id: str,
+        assignee_id: Optional[str] = None,
+        status: PacketStatus = PacketStatus.SENT,
+    ):
+        self.task = task
+        self.publisher_id = publisher_id
+        self.assignee_id = assignee_id
+        self.status = status
+
+    def __repr__(self):
+        return (
+            f"Packet(publisher_id={self.publisher_id}, assignee_id="
+            f"{self.assignee_id}, status={self.status})"
+        )
+
+
+class TaskChannel:
+    r"""An internal class used by Workforce to manage tasks."""
+
+    def __init__(self) -> None:
+        self._task_id_list: List[str] = []
+        self._condition = asyncio.Condition()
+        self._task_dict: Dict[str, Packet] = {}
+
+    async def get_returned_task_by_publisher(self, publisher_id: str) -> Task:
+        await self.print_channel()
+        async with self._condition:
+            while True:
+                for task_id in self._task_id_list:
+                    packet = self._task_dict[task_id]
+                    if packet.publisher_id != publisher_id:
+                        continue
+                    if packet.status != PacketStatus.RETURNED:
+                        continue
+                    return packet.task
+                await self._condition.wait()
+
+    async def get_assigned_task_by_assignee(self, assignee_id: str) -> Task:
+        async with self._condition:
+            while True:
+                for task_id in self._task_id_list:
+                    packet = self._task_dict[task_id]
+                    if (
+                        packet.status == PacketStatus.SENT
+                        and packet.assignee_id == assignee_id
+                    ):
+                        return packet.task
+                await self._condition.wait()
+
+    async def post_task(
+        self, task: Task, publisher_id: str, assignee_id: str
+    ) -> None:
+        r"""Send a task to the channel with specified publisher and assignee,
+        along with the dependency of the task."""
+        async with self._condition:
+            self._task_id_list.append(task.id)
+            packet = Packet(task, publisher_id, assignee_id)
+            self._task_dict[packet.task.id] = packet
+            self._condition.notify_all()
+
+    async def post_dependency(
+        self, dependency: Task, publisher_id: str
+    ) -> None:
+        r"""Post a dependency to the channel. A dependency is a task that is
+        archived, and will be referenced by other tasks."""
+        async with self._condition:
+            self._task_id_list.append(dependency.id)
+            packet = Packet(
+                dependency, publisher_id, status=PacketStatus.ARCHIVED
+            )
+            self._task_dict[packet.task.id] = packet
+            self._condition.notify_all()
+
+    async def return_task(self, task_id: str) -> None:
+        r"""Return a task to the sender, indicating that the task has been
+        processed by the worker."""
+        async with self._condition:
+            packet = self._task_dict[task_id]
+            packet.status = PacketStatus.RETURNED
+            self._condition.notify_all()
+
+    async def archive_task(self, task_id: str) -> None:
+        r"""Archive a task in channel, making it to become a dependency."""
+        async with self._condition:
+            packet = self._task_dict[task_id]
+            packet.status = PacketStatus.ARCHIVED
+            self._condition.notify_all()
+
+    async def remove_task(self, task_id: str) -> None:
+        async with self._condition:
+            self._task_id_list.remove(task_id)
+            self._task_dict.pop(task_id)
+            self._condition.notify_all()
+
+    async def get_dependency_ids(self) -> List[str]:
+        async with self._condition:
+            dependency_ids = []
+            for task_id in self._task_id_list:
+                packet = self._task_dict[task_id]
+                if packet.status == PacketStatus.ARCHIVED:
+                    dependency_ids.append(task_id)
+            return dependency_ids
+
+    async def get_task_by_id(self, task_id: str) -> Task:
+        async with self._condition:
+            if task_id not in self._task_id_list:
+                raise ValueError(f"Task {task_id} not found.")
+            return self._task_dict[task_id].task
+
+    async def print_channel(self):
+        async with self._condition:
+            print(self._task_dict)
+            print(self._task_id_list)

camel/workforce/utils.py

@@ -0,0 +1,97 @@
+# =========== 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 re
+from functools import wraps
+from typing import Callable
+
+
+class NodeConf:
+    def __init__(self, role: str, system: str, description: str):
+        self.role = role
+        self.system = system
+        self.description = description
+
+
+# TODO: integrate structured response directly instead of parsing
+def parse_create_node_resp(response: str) -> NodeConf:
+    r"""Parses the response of the new workforce creation from the manager
+    agent."""
+    config = re.search(r"(<workforce>.*</workforce>)", response, re.DOTALL)
+    if config is None:
+        raise ValueError("No workforce configuration found in the response.")
+    config_raw = config.group(1)
+
+    try:
+        import xml.etree.ElementTree as ET
+
+        root = ET.fromstring(config_raw)
+        workforce_info = {child.tag: child.text for child in root}
+    except Exception as e:
+        raise ValueError(f"Failed to parse workforce configuration: {e}")
+
+    if (
+        "role" not in workforce_info
+        or "system" not in workforce_info
+        or "description" not in workforce_info
+    ):
+        raise ValueError("Missing required fields in workforce configuration.")
+
+    return NodeConf(
+        role=workforce_info["role"] or "",
+        system=workforce_info["system"] or "",
+        description=workforce_info["description"] or "",
+    )
+
+
+def parse_assign_task_resp(response: str) -> str:
+    r"""Parses the response of the task assignment from the manager agent."""
+    assignee_id = re.search(r"<id>(.*)</id>", response)
+    if assignee_id is None:
+        raise ValueError("No assignee found in the response.")
+    return assignee_id.group(1)
+
+
+def parse_task_result_resp(response: str) -> str:
+    r"""Parses the result of the task from the signle agent workforce."""
+    task_result = re.search(r"<result>(.*)</result>", response, re.DOTALL)
+    failed_tag = re.search(r"<failed></failed>", response)
+    if failed_tag:
+        task_result = None
+    if task_result is None:
+        raise ValueError("No result found in the response.")
+    return task_result.group(1)
+
+
+def check_if_running(running: bool) -> Callable:
+    r"""Check if the workforce is (not) running, specified the boolean value.
+    If the workforce is not in the expected status, raise an exception.
+
+    Raises:
+        RuntimeError: If the workforce is not in the expected status.
+    """
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(self, *args, **kwargs):
+            if self._running != running:
+                status = "not running" if running else "running"
+                raise RuntimeError(
+                    f"The workforce is {status}. Cannot perform the "
+                    f"operation {func.__name__}."
+                )
+            return func(self, *args, **kwargs)
+
+        return wrapper
+
+    return decorator

camel/workforce/worker_node.py

@@ -0,0 +1,115 @@
+# =========== 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 __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import List
+
+from colorama import Fore
+
+from camel.tasks.task import Task, TaskState
+from camel.workforce.base import BaseNode
+from camel.workforce.task_channel import TaskChannel
+from camel.workforce.utils import check_if_running
+
+
+class WorkerNode(BaseNode, ABC):
+    r"""A worker node that works on tasks. It is the basic unit of task
+    processing in the workforce system.
+
+    Args:
+        description (str): Description of the node.
+
+    """
+
+    # TODO: Make RolePlaying and Agent scceed from one parent class, so that
+    #   we don't need two different classes for the worker node.
+
+    def __init__(
+        self,
+        description: str,
+    ) -> None:
+        super().__init__(description)
+
+    @abstractmethod
+    async def _process_task(
+        self, task: Task, dependencies: List[Task]
+    ) -> TaskState:
+        r"""Processes a task based on its dependencies.
+
+        Returns:
+            'DONE' if the task is successfully processed,
+            'FAILED' if the processing fails.
+        """
+
+    async def _get_assigned_task(self) -> Task:
+        r"""Get the task assigned to this node from the channel."""
+        return await self._channel.get_assigned_task_by_assignee(self.node_id)
+
+    @staticmethod
+    def _get_dep_tasks_info(dependencies: List[Task]) -> str:
+        result_lines = [
+            f"id: {dep_task.id}, content: {dep_task.content}. "
+            f"result: {dep_task.result}."
+            for dep_task in dependencies
+        ]
+        result_str = "\n".join(result_lines)
+        return result_str
+
+    @check_if_running(False)
+    def set_channel(self, channel: TaskChannel):
+        self._channel = channel
+
+    @check_if_running(False)
+    async def _listen_to_channel(self):
+        """Continuously listen to the channel, process the task that are
+        assigned to this node, and update the result and status of the task.
+
+        This method should be run in an event loop, as it will run
+            indefinitely.
+        """
+        self._running = True
+        print(f"{Fore.GREEN}Worker node {self.node_id} started.{Fore.RESET}")
+
+        while True:
+            # get the earliest task assigned to this node
+            task = await self._get_assigned_task()
+            print(
+                f'worker node {self.node_id} get task:',
+                task.id,
+                task.content,
+            )
+            # get the Task instance of dependencies
+            dependency_ids = await self._channel.get_dependency_ids()
+            task_dependencies = [
+                await self._channel.get_task_by_id(dep_id)
+                for dep_id in dependency_ids
+            ]
+
+            # process the task
+            task_state = await self._process_task(task, task_dependencies)
+
+            # update the result and status of the task
+            task.set_state(task_state)
+
+            await self._channel.return_task(task.id)
+
+    @check_if_running(False)
+    async def start(self):
+        await self._listen_to_channel()
+
+    @check_if_running(True)
+    def stop(self):
+        self._running = False
+        return

camel/workforce/workforce.py

@@ -0,0 +1,49 @@
+# =========== 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 asyncio
+
+from camel.tasks import Task
+from camel.workforce.manager_node import ManagerNode
+from camel.workforce.task_channel import TaskChannel
+
+
+class Workforce:
+    r"""A class representing a workforce system.
+
+    Args:
+        name (str, optional): The name of the workforce system. Defaults to
+            `"CAMEL Workforce"`.
+        description (str, optional): A description of the workforce system.
+            Defaults to `"A workforce system for managing tasks."`.
+    """
+
+    def __init__(
+        self,
+        root_node: ManagerNode,
+        name: str = "CAMEL Workforce",
+        description: str = "A workforce system for managing tasks.",
+    ) -> None:
+        self.name = name
+        self.description = description
+        self._root_node = root_node
+
+    def process_task(self, task: Task) -> Task:
+        self._root_node.set_main_task(task)
+        shared_channel = TaskChannel()
+        self._root_node.set_channel(shared_channel)
+
+        # start the root workforce
+        asyncio.run(self._root_node.start())
+
+        return task