camel-ai 0.2.66__py3-none-any.whl → 0.2.68__py3-none-any.whl

camel/societies/workforce/role_playing_worker.py

@@ -28,7 +28,6 @@ from camel.societies.workforce.prompts import (
 from camel.societies.workforce.utils import TaskResult
 from camel.societies.workforce.worker import Worker
 from camel.tasks.task import Task, TaskState, validate_task_content
-from camel.utils import print_text_animated
 
 
 class RolePlayingWorker(Worker):
@@ -141,24 +140,20 @@ class RolePlayingWorker(Worker):
                 )
                 break
 
-            print_text_animated(
+            print(
                 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
-            )
+            print(f"{Fore.GREEN}AI Assistant:{Fore.RESET}")
 
             for func_record in assistant_response.info['tool_calls']:
                 print(func_record)
 
-            print_text_animated(
+            print(
                 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}"

camel/societies/workforce/single_agent_worker.py

@@ -24,7 +24,6 @@ from camel.societies.workforce.prompts import PROCESS_TASK_PROMPT
 from camel.societies.workforce.utils import TaskResult
 from camel.societies.workforce.worker import Worker
 from camel.tasks.task import Task, TaskState, validate_task_content
-from camel.utils import print_text_animated
 
 
 class SingleAgentWorker(Worker):
@@ -33,15 +32,22 @@ class SingleAgentWorker(Worker):
     Args:
         description (str): Description of the node.
         worker (ChatAgent): Worker of the node. A single agent.
+        max_concurrent_tasks (int): Maximum number of tasks this worker can
+            process concurrently. (default: :obj:`10`)
     """
 
     def __init__(
         self,
         description: str,
         worker: ChatAgent,
+        max_concurrent_tasks: int = 10,
     ) -> None:
         node_id = worker.agent_id
-        super().__init__(description, node_id=node_id)
+        super().__init__(
+            description,
+            node_id=node_id,
+            max_concurrent_tasks=max_concurrent_tasks,
+        )
         self.worker = worker
 
     def reset(self) -> Any:
@@ -52,11 +58,12 @@ class SingleAgentWorker(Worker):
     async def _process_task(
         self, task: Task, dependencies: List[Task]
     ) -> TaskState:
-        r"""Processes a task with its dependencies.
+        r"""Processes a task with its dependencies using a cloned agent.
 
         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.
+        dependencies, by sending a generated prompt to a cloned worker agent.
+        Using a cloned agent ensures that concurrent tasks don't interfere
+        with each other's state.
 
         Args:
             task (Task): The task to process, which includes necessary details
@@ -67,6 +74,10 @@ class SingleAgentWorker(Worker):
             TaskState: `TaskState.DONE` if processed successfully, otherwise
                 `TaskState.FAILED`.
         """
+        # Clone the agent for this specific task to avoid state conflicts
+        # when processing multiple tasks concurrently
+        worker_agent = self.worker.clone(with_memory=False)
+
         dependency_tasks_info = self._get_dep_tasks_info(dependencies)
         prompt = PROCESS_TASK_PROMPT.format(
             content=task.content,
@@ -74,7 +85,7 @@ class SingleAgentWorker(Worker):
             additional_info=task.additional_info,
         )
         try:
-            response = await self.worker.astep(
+            response = await worker_agent.astep(
                 prompt, response_format=TaskResult
             )
         except Exception as e:
@@ -84,6 +95,13 @@ class SingleAgentWorker(Worker):
             )
             return TaskState.FAILED
 
+        # Get actual token usage from the cloned agent that processed this task
+        try:
+            _, total_token_count = worker_agent.memory.get_context()
+        except Exception:
+            # Fallback if memory context unavailable
+            total_token_count = 0
+
         # Populate additional_info with worker attempt details
         if task.additional_info is None:
             task.additional_info = {}
@@ -91,14 +109,20 @@ class SingleAgentWorker(Worker):
         # Create worker attempt details with descriptive keys
         worker_attempt_details = {
             "agent_id": getattr(
+                worker_agent, "agent_id", worker_agent.role_name
+            ),
+            "original_worker_id": getattr(
                 self.worker, "agent_id", self.worker.role_name
             ),
             "timestamp": str(datetime.datetime.now()),
             "description": f"Attempt by "
-            f"{getattr(self.worker, 'agent_id', self.worker.role_name)} "
+            f"{getattr(worker_agent, 'agent_id', worker_agent.role_name)} "
+            f"(cloned from "
+            f"{getattr(self.worker, 'agent_id', self.worker.role_name)}) "
             f"to process task {task.content}",
             "response_content": response.msg.content,
             "tool_calls": response.info["tool_calls"],
+            "total_token_count": total_token_count,
         }
 
         # Store the worker attempt in additional_info
@@ -106,15 +130,19 @@ class SingleAgentWorker(Worker):
             task.additional_info["worker_attempts"] = []
         task.additional_info["worker_attempts"].append(worker_attempt_details)
 
+        # Store the actual token usage for this specific task
+        task.additional_info["token_usage"] = {
+            "total_tokens": total_token_count
+        }
+
         print(f"======\n{Fore.GREEN}Reply from {self}:{Fore.RESET}")
 
         result_dict = json.loads(response.msg.content)
         task_result = TaskResult(**result_dict)
 
         color = Fore.RED if task_result.failed else Fore.GREEN
-        print_text_animated(
+        print(
             f"\n{color}{task_result.content}{Fore.RESET}\n======",
-            delay=0.005,
         )
 
         if task_result.failed:

camel/societies/workforce/task_channel.py

@@ -23,6 +23,8 @@ class PacketStatus(Enum):
     states:
 
     - ``SENT``: The packet has been sent to a worker.
+    - ``PROCESSING``: The packet has been claimed by a worker and is being
+    processed.
     - ``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
@@ -31,6 +33,7 @@ class PacketStatus(Enum):
     """
 
     SENT = "SENT"
+    PROCESSING = "PROCESSING"
     RETURNED = "RETURNED"
     ARCHIVED = "ARCHIVED"
 
@@ -79,7 +82,6 @@ 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] = {}
 
@@ -89,8 +91,7 @@ class TaskChannel:
         """
         async with self._condition:
             while True:
-                for task_id in self._task_id_list:
-                    packet = self._task_dict[task_id]
+                for packet in self._task_dict.values():
                     if packet.publisher_id != publisher_id:
                         continue
                     if packet.status != PacketStatus.RETURNED:
@@ -99,17 +100,20 @@ class TaskChannel:
                 await self._condition.wait()
 
     async def get_assigned_task_by_assignee(self, assignee_id: str) -> Task:
-        r"""Get a task from the channel that has been assigned to the
-        assignee.
+        r"""Atomically get and claim a task from the channel that has been
+        assigned to the assignee. This prevents race conditions where multiple
+        concurrent calls might retrieve the same task.
         """
         async with self._condition:
             while True:
-                for task_id in self._task_id_list:
-                    packet = self._task_dict[task_id]
+                for packet in self._task_dict.values():
                     if (
                         packet.status == PacketStatus.SENT
                         and packet.assignee_id == assignee_id
                     ):
+                        # Atomically claim the task by changing its status
+                        packet.status = PacketStatus.PROCESSING
+                        self._condition.notify_all()
                         return packet.task
                 await self._condition.wait()
 
@@ -119,7 +123,6 @@ class TaskChannel:
         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()
@@ -130,7 +133,6 @@ class TaskChannel:
         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
             )
@@ -141,30 +143,32 @@ class TaskChannel:
         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
+            if task_id in self._task_dict:
+                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
+            if task_id in self._task_dict:
+                packet = self._task_dict[task_id]
+                packet.status = PacketStatus.ARCHIVED
             self._condition.notify_all()
 
     async def remove_task(self, task_id: str) -> None:
         r"""Remove a task from the channel."""
         async with self._condition:
-            self._task_id_list.remove(task_id)
-            self._task_dict.pop(task_id)
+            # Check if task ID exists before removing
+            if task_id in self._task_dict:
+                del self._task_dict[task_id]
             self._condition.notify_all()
 
     async def get_dependency_ids(self) -> List[str]:
         r"""Get the IDs of all dependencies in the channel."""
         async with self._condition:
             dependency_ids = []
-            for task_id in self._task_id_list:
-                packet = self._task_dict[task_id]
+            for task_id, packet in self._task_dict.items():
                 if packet.status == PacketStatus.ARCHIVED:
                     dependency_ids.append(task_id)
             return dependency_ids
@@ -172,11 +176,12 @@ class TaskChannel:
     async def get_task_by_id(self, task_id: str) -> Task:
         r"""Get a task from the channel by its ID."""
         async with self._condition:
-            if task_id not in self._task_id_list:
+            packet = self._task_dict.get(task_id)
+            if packet is None:
                 raise ValueError(f"Task {task_id} not found.")
-            return self._task_dict[task_id].task
+            return packet.task
 
     async def get_channel_debug_info(self) -> str:
         r"""Get the debug information of the channel."""
         async with self._condition:
-            return str(self._task_dict) + '\n' + str(self._task_id_list)
+            return str(self._task_dict)

camel/societies/workforce/utils.py

@@ -12,7 +12,7 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from functools import wraps
-from typing import Callable
+from typing import Callable, List
 
 from pydantic import BaseModel, Field
 
@@ -41,32 +41,122 @@ class TaskResult(BaseModel):
     )
 
 
-class TaskAssignResult(BaseModel):
-    r"""The result of task assignment."""
+class TaskAssignment(BaseModel):
+    r"""An individual task assignment within a batch."""
 
+    task_id: str = Field(description="The ID of the task to be assigned.")
     assignee_id: str = Field(
-        description="The ID of the workforce that is assigned to the task."
+        description="The ID of the worker/workforce to assign the task to."
+    )
+    dependencies: List[str] = Field(
+        default_factory=list,
+        description="List of task IDs that must complete before this task.",
+    )
+
+
+class TaskAssignResult(BaseModel):
+    r"""The result of task assignment for both single and batch assignments."""
+
+    assignments: List[TaskAssignment] = Field(
+        description="List of task assignments."
     )
 
 
-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.
+def check_if_running(
+    running: bool,
+    max_retries: int = 3,
+    retry_delay: float = 1.0,
+    handle_exceptions: bool = False,
+) -> Callable:
+    r"""Check if the workforce is (not) running, specified by the boolean
+    value. Provides fault tolerance through automatic retries and exception
+    handling.
+
+    Args:
+        running (bool): Expected running state (True or False).
+        max_retries (int, optional): Maximum number of retry attempts if the
+            operation fails. Set to 0 to disable retries. (default: :obj:`3`)
+        retry_delay (float, optional): Delay in seconds between retry attempts.
+            (default: :obj:`1.0`)
+        handle_exceptions (bool, optional): If True, catch and log exceptions
+            instead of propagating them. (default: :obj:`False`)
 
     Raises:
-        RuntimeError: If the workforce is not in the expected status.
+        RuntimeError: If the workforce is not in the expected status and
+            retries are exhausted or disabled.
+        Exception: Any exception raised by the decorated function if
+            handle_exceptions is False and retries are exhausted.
     """
+    import logging
+    import time
+
+    logger = logging.getLogger(__name__)
 
     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__}."
+            retries = 0
+            last_exception = None
+
+            while retries <= max_retries:
+                try:
+                    # Check running state
+                    if self._running != running:
+                        status = "not running" if running else "running"
+                        error_msg = (
+                            f"The workforce is {status}. Cannot perform the "
+                            f"operation {func.__name__}."
+                        )
+
+                        # If we have retries left, wait and try again
+                        if retries < max_retries:
+                            logger.warning(
+                                f"{error_msg} Retrying in {retry_delay}s... "
+                                f"(Attempt {retries+1}/{max_retries})"
+                            )
+                            time.sleep(retry_delay)
+                            retries += 1
+                            continue
+                        else:
+                            raise RuntimeError(error_msg)
+
+                    return func(self, *args, **kwargs)
+
+                except Exception as e:
+                    last_exception = e
+
+                    if isinstance(e, RuntimeError) and "workforce is" in str(
+                        e
+                    ):
+                        raise
+
+                    if retries < max_retries:
+                        logger.warning(
+                            f"Exception in {func.__name__}: {e}. "
+                            f"Retrying in {retry_delay}s... "
+                            f"(Attempt {retries+1}/{max_retries})"
+                        )
+                        time.sleep(retry_delay)
+                        retries += 1
+                    else:
+                        if handle_exceptions:
+                            logger.error(
+                                f"Failed to execute {func.__name__} after "
+                                f"{max_retries} retries: {e}"
+                            )
+                            return None
+                        else:
+                            # Re-raise the exception
+                            raise
+
+            # This should not be reached, but just in case
+            if handle_exceptions:
+                logger.error(
+                    f"Unexpected failure in {func.__name__}: {last_exception}"
                 )
-            return func(self, *args, **kwargs)
+                return None
+            else:
+                raise last_exception
 
         return wrapper
 

camel/societies/workforce/worker.py

@@ -13,9 +13,10 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from __future__ import annotations
 
+import asyncio
 import logging
 from abc import ABC, abstractmethod
-from typing import List, Optional
+from typing import List, Optional, Set
 
 from colorama import Fore
 
@@ -35,14 +36,19 @@ class Worker(BaseNode, ABC):
         description (str): Description of the node.
         node_id (Optional[str]): ID of the node. If not provided, it will
             be generated automatically. (default: :obj:`None`)
+        max_concurrent_tasks (int): Maximum number of tasks this worker can
+            process concurrently. (default: :obj:`10`)
     """
 
     def __init__(
         self,
         description: str,
         node_id: Optional[str] = None,
+        max_concurrent_tasks: int = 10,
     ) -> None:
         super().__init__(description, node_id=node_id)
+        self.max_concurrent_tasks = max_concurrent_tasks
+        self._active_task_ids: Set[str] = set()
 
     def __repr__(self):
         return f"Worker node {self.node_id} ({self.description})"
@@ -60,7 +66,7 @@ class Worker(BaseNode, ABC):
         pass
 
     async def _get_assigned_task(self) -> Task:
-        r"""Get the task assigned to this node from the channel."""
+        r"""Get a task assigned to this node from the channel."""
         return await self._channel.get_assigned_task_by_assignee(self.node_id)
 
     @staticmethod
@@ -77,20 +83,10 @@ class Worker(BaseNode, ABC):
     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
-        logger.info(f"{self} started.")
-
-        while True:
-            # Get the earliest task assigned to this node
-            task = await self._get_assigned_task()
+    async def _process_single_task(self, task: Task) -> None:
+        r"""Process a single task and handle its completion/failure."""
+        try:
+            self._active_task_ids.add(task.id)
             print(
                 f"{Fore.YELLOW}{self} get task {task.id}: {task.content}"
                 f"{Fore.RESET}"
@@ -109,6 +105,92 @@ class Worker(BaseNode, ABC):
             task.set_state(task_state)
 
             await self._channel.return_task(task.id)
+        except Exception as e:
+            logger.error(f"Error processing task {task.id}: {e}")
+            task.set_state(TaskState.FAILED)
+            await self._channel.return_task(task.id)
+        finally:
+            self._active_task_ids.discard(task.id)
+
+    @check_if_running(False)
+    async def _listen_to_channel(self):
+        r"""Continuously listen to the channel, process tasks that are
+        assigned to this node concurrently up to max_concurrent_tasks limit.
+
+        This method supports parallel task execution when multiple tasks
+        are assigned to the same worker.
+        """
+        self._running = True
+        logger.info(
+            f"{self} started with max {self.max_concurrent_tasks} "
+            f"concurrent tasks."
+        )
+
+        # Keep track of running task coroutines
+        running_tasks: Set[asyncio.Task] = set()
+
+        while self._running:
+            try:
+                # Clean up completed tasks
+                completed_tasks = [t for t in running_tasks if t.done()]
+                for completed_task in completed_tasks:
+                    running_tasks.remove(completed_task)
+                    # Check for exceptions in completed tasks
+                    try:
+                        await completed_task
+                    except Exception as e:
+                        logger.error(f"Task processing failed: {e}")
+
+                # Check if we can accept more tasks
+                if len(running_tasks) < self.max_concurrent_tasks:
+                    try:
+                        # Try to get a new task (with short timeout to avoid
+                        # blocking)
+                        task = await asyncio.wait_for(
+                            self._get_assigned_task(), timeout=1.0
+                        )
+
+                        # Create and start processing task
+                        task_coroutine = asyncio.create_task(
+                            self._process_single_task(task)
+                        )
+                        running_tasks.add(task_coroutine)
+
+                    except asyncio.TimeoutError:
+                        # No tasks available, continue loop
+                        if not running_tasks:
+                            # No tasks running and none available, short sleep
+                            await asyncio.sleep(0.1)
+                        continue
+                else:
+                    # At max capacity, wait for at least one task to complete
+                    if running_tasks:
+                        done, running_tasks = await asyncio.wait(
+                            running_tasks, return_when=asyncio.FIRST_COMPLETED
+                        )
+                        # Process completed tasks
+                        for completed_task in done:
+                            try:
+                                await completed_task
+                            except Exception as e:
+                                logger.error(f"Task processing failed: {e}")
+
+            except Exception as e:
+                logger.error(
+                    f"Error in worker {self.node_id} listen loop: {e}"
+                )
+                await asyncio.sleep(0.1)
+                continue
+
+        # Wait for all remaining tasks to complete when stopping
+        if running_tasks:
+            logger.info(
+                f"{self} stopping, waiting for {len(running_tasks)} "
+                f"tasks to complete..."
+            )
+            await asyncio.gather(*running_tasks, return_exceptions=True)
+
+        logger.info(f"{self} stopped.")
 
     @check_if_running(False)
     async def start(self):