camel-ai 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

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,39 @@ 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,
+            response = self.worker.step(req, output_schema=TaskResult)
+        except Exception as e:
+            print(
+                f"{Fore.RED}Error occurred while processing task {task.id}:"
+                f"\n{e}{Fore.RESET}"
             )
-            req = BaseMessage.make_user_message(
-                role_name="User",
-                content=prompt,
+            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)
+
+        if task_result.failed:
+            print(
+                f"{Fore.RED}{self} failed to process task {task.id}.\n======"
             )
-            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
+
+        task.result = task_result.content
+        print_text_animated(
+            f'\n{Fore.GREEN}{task.result}{Fore.RESET}\n======',
+            delay=0.005,
+        )
+        return TaskState.DONE

camel/workforce/task_channel.py

@@ -61,7 +61,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 +83,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 +166,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)