camel-ai 0.1.9__py3-none-any.whl → 0.2.3__py3-none-any.whl

camel/workforce/role_playing_worker.py

@@ -0,0 +1,181 @@
+# =========== 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
+
+import ast
+from typing import Dict, List, Optional
+
+from colorama import Fore
+
+from camel.agents.chat_agent import ChatAgent
+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.prompts import (
+    ROLEPLAY_PROCESS_TASK_PROMPT,
+    ROLEPLAY_SUMMARIZE_PROMPT,
+)
+from camel.workforce.utils import TaskResult
+from camel.workforce.worker import Worker
+
+
+class RolePlayingWorker(Worker):
+    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)
+        summ_sys_msg = BaseMessage.make_assistant_message(
+            role_name="Summarizer",
+            content="You are a good summarizer. You will be presented with "
+            "scenarios where an assistant and a user with specific roles "
+            "are trying to solve a task. Your job is summarizing the result "
+            "of the task based on the chat history.",
+        )
+        self.summarize_agent = ChatAgent(summ_sys_msg)
+        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`.
+        """
+        dependency_tasks_info = self._get_dep_tasks_info(dependencies)
+        prompt = ROLEPLAY_PROCESS_TASK_PROMPT.format(
+            content=task.content,
+            dependency_task_info=dependency_tasks_info,
+            additional_info=task.additional_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(
+                    f"{Fore.GREEN}AI Assistant terminated. Reason: "
+                    f"{reason}.{Fore.RESET}"
+                )
+                break
+
+            if user_response.terminated:
+                reason = user_response.info['termination_reasons']
+                print(
+                    f"{Fore.GREEN}AI User terminated. Reason: {reason}."
+                    f"{Fore.RESET}"
+                )
+                break
+
+            print_text_animated(
+                f"{Fore.BLUE}AI User:\n\n{user_response.msg.content}"
+                f"{Fore.RESET}\n",
+                delay=0.005,
+            )
+            chat_history.append(f"AI User: {user_response.msg.content}")
+
+            print_text_animated(
+                f"{Fore.GREEN}AI Assistant:{Fore.RESET}", delay=0.005
+            )
+
+            for func_record in assistant_response.info['tool_calls']:
+                print(func_record)
+
+            print_text_animated(
+                f"\n{Fore.GREEN}{assistant_response.msg.content}"
+                f"{Fore.RESET}\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_SUMMARIZE_PROMPT.format(
+            user_role=self.user_role_name,
+            assistant_role=self.assistant_role_name,
+            content=task.content,
+            chat_history=chat_history_str,
+            additional_info=task.additional_info,
+        )
+        req = BaseMessage.make_user_message(
+            role_name="User",
+            content=prompt,
+        )
+        response = self.summarize_agent.step(req, response_format=TaskResult)
+        result_dict = ast.literal_eval(response.msg.content)
+        task_result = TaskResult(**result_dict)
+        task.result = task_result.content
+
+        print(f"Task result: {task.result}\n")
+        return TaskState.DONE

camel/workforce/{single_agent_node.py → single_agent_worker.py}

@@ -13,32 +13,41 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from __future__ import annotations
 
-from typing import List
+import ast
+from typing import Any, List
 
-from camel.agents.base import BaseAgent
+from colorama import Fore
+
+from camel.agents import ChatAgent
 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
+from camel.utils import print_text_animated
+from camel.workforce.prompts import PROCESS_TASK_PROMPT
+from camel.workforce.utils import TaskResult
+from camel.workforce.worker import Worker
 
 
-class SingleAgentNode(WorkerNode):
+class SingleAgentWorker(Worker):
     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.
+        worker (ChatAgent): Worker of the node. A single agent.
     """
 
     def __init__(
         self,
         description: str,
-        worker: BaseAgent,
+        worker: ChatAgent,
     ) -> None:
         super().__init__(description)
         self.worker = worker
 
+    def reset(self) -> Any:
+        r"""Resets the worker to its initial state."""
+        super().reset()
+        self.worker.reset()
+
     async def _process_task(
         self, task: Task, dependencies: List[Task]
     ) -> TaskState:
@@ -57,21 +66,38 @@ class SingleAgentNode(WorkerNode):
             TaskState: `TaskState.DONE` if processed successfully, otherwise
                 `TaskState.FAILED`.
         """
+        dependency_tasks_info = self._get_dep_tasks_info(dependencies)
+        prompt = PROCESS_TASK_PROMPT.format(
+            content=task.content,
+            dependency_tasks_info=dependency_tasks_info,
+            additional_info=task.additional_info,
+        )
+        req = BaseMessage.make_user_message(
+            role_name="User",
+            content=prompt,
+        )
         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, response_format=TaskResult)
+        except Exception as e:
+            print(
+                f"{Fore.RED}Error occurred while processing task {task.id}:"
+                f"\n{e}{Fore.RESET}"
             )
-            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
+
+        print(f"======\n{Fore.GREEN}Reply from {self}:{Fore.RESET}")
+
+        result_dict = ast.literal_eval(response.msg.content)
+        task_result = TaskResult(**result_dict)
+
+        color = Fore.RED if task_result.failed else Fore.GREEN
+        print_text_animated(
+            f"\n{color}{task_result.content}{Fore.RESET}\n======",
+            delay=0.005,
+        )
+
+        if task_result.failed:
+            return TaskState.FAILED
+
+        task.result = task_result.content
+        return TaskState.DONE

camel/workforce/task_channel.py

@@ -21,12 +21,13 @@ 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.
+      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.
+      the task inside will not be changed. The task is considered
+      as a dependency.
     """
 
     SENT = "SENT"
@@ -61,7 +62,7 @@ class Packet:
         publisher_id: str,
         assignee_id: Optional[str] = None,
         status: PacketStatus = PacketStatus.SENT,
-    ):
+    ) -> None:
         self.task = task
         self.publisher_id = publisher_id
         self.assignee_id = assignee_id
@@ -83,7 +84,6 @@ class TaskChannel:
         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:
@@ -167,7 +167,6 @@ class TaskChannel:
                 raise ValueError(f"Task {task_id} not found.")
             return self._task_dict[task_id].task
 
-    async def print_channel(self):
+    async def get_channel_debug_info(self) -> str:
         async with self._condition:
-            print(self._task_dict)
-            print(self._task_id_list)
+            return str(self._task_dict) + '\n' + str(self._task_id_list)

camel/workforce/utils.py

@@ -11,66 +11,36 @@
 # 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
 
+from pydantic import BaseModel, Field
 
-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 "",
+class WorkerConf(BaseModel):
+    role: str = Field(
+        description="The role of the agent working in the work node."
+    )
+    sys_msg: str = Field(
+        description="The system message that will be sent to the agent in "
+        "the node."
+    )
+    description: str = Field(
+        description="The description of the new work node itself."
     )
 
 
-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)
+class TaskResult(BaseModel):
+    content: str = Field(description="The result of the task.")
+    failed: bool = Field(
+        description="Flag indicating whether the task processing failed."
+    )
 
 
-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)
+class TaskAssignResult(BaseModel):
+    assignee_id: str = Field(
+        description="The ID of the workforce that is assigned to the task."
+    )
 
 
 def check_if_running(running: bool) -> Callable:

camel/workforce/{worker_node.py → worker.py}

@@ -13,6 +13,7 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from __future__ import annotations
 
+import logging
 from abc import ABC, abstractmethod
 from typing import List
 
@@ -23,8 +24,10 @@ from camel.workforce.base import BaseNode
 from camel.workforce.task_channel import TaskChannel
 from camel.workforce.utils import check_if_running
 
+logger = logging.getLogger(__name__)
 
-class WorkerNode(BaseNode, ABC):
+
+class Worker(BaseNode, ABC):
     r"""A worker node that works on tasks. It is the basic unit of task
     processing in the workforce system.
 
@@ -33,15 +36,15 @@ class WorkerNode(BaseNode, ABC):
 
     """
 
-    # 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)
 
+    def __repr__(self):
+        return f"Worker node {self.node_id} ({self.description})"
+
     @abstractmethod
     async def _process_task(
         self, task: Task, dependencies: List[Task]
@@ -52,6 +55,7 @@ class WorkerNode(BaseNode, ABC):
             'DONE' if the task is successfully processed,
             'FAILED' if the processing fails.
         """
+        pass
 
     async def _get_assigned_task(self) -> Task:
         r"""Get the task assigned to this node from the channel."""
@@ -80,27 +84,26 @@ class WorkerNode(BaseNode, ABC):
             indefinitely.
         """
         self._running = True
-        print(f"{Fore.GREEN}Worker node {self.node_id} started.{Fore.RESET}")
+        logger.info(f"{self} started.")
 
         while True:
-            # get the earliest task assigned to this node
+            # 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,
+                f"{Fore.YELLOW}{self} get task {task.id}: {task.content}"
+                f"{Fore.RESET}"
             )
-            # get the Task instance of dependencies
+            # 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
+            # Process the task
             task_state = await self._process_task(task, task_dependencies)
 
-            # update the result and status of the task
+            # Update the result and status of the task
             task.set_state(task_state)
 
             await self._channel.return_task(task.id)