camel-ai 0.2.68__py3-none-any.whl → 0.2.69a1__py3-none-any.whl

camel/runtimes/remote_http_runtime.py

@@ -36,9 +36,9 @@ class RemoteHttpRuntime(BaseRuntime):
 
     Args:
         host (str): The host of the remote server.
-        port (int): The port of the remote server. (default: :obj: `8000`)
+        port (int): The port of the remote server. (default: :obj:`8000`)
         python_exec (str): The python executable to run the API server.
-            (default: :obj: `python3`)
+            (default: :obj:`python3`)
     """
 
     def __init__(
@@ -90,9 +90,9 @@ class RemoteHttpRuntime(BaseRuntime):
                 list of functions to add.
             entrypoint (str): The entrypoint for the function.
             redirect_stdout (bool): Whether to return the stdout of
-                the function. (default: :obj: `False`)
+                the function. (default: :obj:`False`)
             arguments (Optional[Dict[str, Any]]): The arguments for the
-                function. (default: :obj: `None`)
+                function. (default: :obj:`None`)
 
         Returns:
             RemoteHttpRuntime: The current runtime.
@@ -162,7 +162,7 @@ class RemoteHttpRuntime(BaseRuntime):
         r"""Wait for the API Server to be ready.
 
         Args:
-            timeout (int): The number of seconds to wait. (default: :obj: `10`)
+            timeout (int): The number of seconds to wait. (default: :obj:`10`)
 
         Returns:
             bool: Whether the API Server is ready.

camel/societies/workforce/prompts.py

@@ -49,17 +49,6 @@ The information returned should be concise and clear.
 ASSIGN_TASK_PROMPT = TextPrompt(
     """You need to assign multiple tasks to worker nodes based on the information below.
 
-Here are the tasks to be assigned:
-==============================
-{tasks_info}
-==============================
-
-Following is the information of the existing worker nodes. The format is <ID>:<description>:<additional_info>. Choose the most capable worker node ID for each task.
-
-==============================
-{child_nodes_info}
-==============================
-
 For each task, you need to:
 1. Choose the most capable worker node ID for that task
 2. Identify any dependencies between tasks (if task B requires results from task A, then task A is a dependency of task B)
@@ -80,9 +69,21 @@ Example valid response:
   ]
 }}
 
-IMPORTANT: Only add dependencies when one task truly needs the output/result of another task to complete successfully. Don't add dependencies unless they are logically necessary.
+***CRITICAL: DEPENDENCY MANAGEMENT IS YOUR IMPORTANT RESPONSIBILITY.***
+Carefully analyze the sequence of tasks. A task's dependencies MUST include the IDs of all prior tasks whose outputs are necessary for its execution. For example, a task to 'Summarize Paper X' MUST depend on the task that 'Finds/Retrieves Paper X'. Similarly, a task that 'Compiles a report from summaries' MUST depend on all 'Summarize Paper X' tasks. **Incorrect or missing dependencies will lead to critical operational failures and an inability to complete the overall objective.** Be meticulous in defining these relationships.
 
 Do not include any other text, explanations, justifications, or conversational filler before or after the JSON object. Return ONLY the JSON object.
+
+Here are the tasks to be assigned:
+==============================
+{tasks_info}
+==============================
+
+Following is the information of the existing worker nodes. The format is <ID>:<description>:<additional_info>. Choose the most capable worker node ID for each task.
+
+==============================
+{child_nodes_info}
+==============================
 """
 )
 

camel/societies/workforce/single_agent_worker.py

@@ -13,9 +13,12 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from __future__ import annotations
 
+import asyncio
 import datetime
 import json
-from typing import Any, List
+import time
+from collections import deque
+from typing import Any, List, Optional
 
 from colorama import Fore
 
@@ -26,44 +29,237 @@ from camel.societies.workforce.worker import Worker
 from camel.tasks.task import Task, TaskState, validate_task_content
 
 
+class AgentPool:
+    r"""A pool of agent instances for efficient reuse.
+
+    This pool manages a collection of pre-cloned agents. It supports
+    auto-scaling based ondemand and intelligent reuse of existing agents.
+
+    Args:
+        base_agent (ChatAgent): The base agent to clone from.
+        initial_size (int): Initial number of agents in the pool.
+            (default: :obj:`1`)
+        max_size (int): Maximum number of agents in the pool.
+            (default: :obj:`10`)
+        auto_scale (bool): Whether to automatically scale the pool size.
+            (default: :obj:`True`)
+        scale_factor (float): Factor by which to scale the pool when needed.
+            (default: :obj:`1.5`)
+        idle_timeout (float): Time in seconds after which idle agents are
+            removed. (default: :obj:`180.0`)
+    """
+
+    def __init__(
+        self,
+        base_agent: ChatAgent,
+        initial_size: int = 1,
+        max_size: int = 10,
+        auto_scale: bool = True,
+        scale_factor: float = 1.5,
+        idle_timeout: float = 180.0,  # 3 minutes
+    ):
+        self.base_agent = base_agent
+        self.max_size = max_size
+        self.auto_scale = auto_scale
+        self.scale_factor = scale_factor
+        self.idle_timeout = idle_timeout
+
+        # Pool management
+        self._available_agents: deque = deque()
+        self._in_use_agents: set = set()
+        self._agent_last_used: dict = {}
+        self._lock = asyncio.Lock()
+
+        # Statistics
+        self._total_borrows = 0
+        self._total_clones_created = 0
+        self._pool_hits = 0
+
+        # Initialize pool
+        self._initialize_pool(initial_size)
+
+    def _initialize_pool(self, size: int) -> None:
+        r"""Initialize the pool with the specified number of agents."""
+        for _ in range(min(size, self.max_size)):
+            agent = self._create_fresh_agent()
+            self._available_agents.append(agent)
+
+    def _create_fresh_agent(self) -> ChatAgent:
+        r"""Create a fresh agent instance."""
+        agent = self.base_agent.clone(with_memory=False)
+        self._total_clones_created += 1
+        return agent
+
+    async def get_agent(self) -> ChatAgent:
+        r"""Get an agent from the pool, creating one if necessary."""
+        async with self._lock:
+            self._total_borrows += 1
+
+            # Try to get from available agents first
+            if self._available_agents:
+                agent = self._available_agents.popleft()
+                self._in_use_agents.add(id(agent))
+                self._pool_hits += 1
+
+                # Reset the agent state
+                agent.reset()
+                return agent
+
+            # Check if we can create new agents
+            total_agents = len(self._available_agents) + len(
+                self._in_use_agents
+            )
+            if total_agents < self.max_size:
+                agent = self._create_fresh_agent()
+                self._in_use_agents.add(id(agent))
+                return agent
+
+            # Pool exhausted, wait and retry or create temporary agent
+            if self.auto_scale:
+                # Create a temporary agent that won't be returned to pool
+                return self._create_fresh_agent()
+            else:
+                # Wait for an agent to become available
+                while not self._available_agents:
+                    await asyncio.sleep(0.1)
+
+                agent = self._available_agents.popleft()
+                self._in_use_agents.add(id(agent))
+                agent.reset()
+                return agent
+
+    async def return_agent(self, agent: ChatAgent) -> None:
+        r"""Return an agent to the pool."""
+        async with self._lock:
+            agent_id = id(agent)
+
+            if agent_id in self._in_use_agents:
+                self._in_use_agents.remove(agent_id)
+
+                # Only return to pool if we're under max size
+                if len(self._available_agents) < self.max_size:
+                    # Reset agent state before returning to pool
+                    agent.reset()
+                    self._available_agents.append(agent)
+                    self._agent_last_used[agent_id] = time.time()
+
+    async def cleanup_idle_agents(self) -> None:
+        r"""Remove idle agents from the pool to free memory."""
+        if not self.auto_scale:
+            return
+
+        async with self._lock:
+            current_time = time.time()
+            agents_to_remove = []
+
+            for agent in list(self._available_agents):
+                agent_id = id(agent)
+                last_used = self._agent_last_used.get(agent_id, current_time)
+
+                if current_time - last_used > self.idle_timeout:
+                    agents_to_remove.append(agent)
+
+            for agent in agents_to_remove:
+                self._available_agents.remove(agent)
+                agent_id = id(agent)
+                self._agent_last_used.pop(agent_id, None)
+
+    def get_stats(self) -> dict:
+        r"""Get pool statistics."""
+        return {
+            "available_agents": len(self._available_agents),
+            "in_use_agents": len(self._in_use_agents),
+            "total_borrows": self._total_borrows,
+            "total_clones_created": self._total_clones_created,
+            "pool_hits": self._pool_hits,
+            "hit_rate": self._pool_hits / max(self._total_borrows, 1),
+        }
+
+
 class SingleAgentWorker(Worker):
     r"""A worker node that consists of a single agent.
 
     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`)
+        use_agent_pool (bool): Whether to use agent pool for efficiency.
+            (default: :obj:`True`)
+        pool_initial_size (int): Initial size of the agent pool.
+            (default: :obj:`1`)
+        pool_max_size (int): Maximum size of the agent pool.
+            (default: :obj:`10`)
+        auto_scale_pool (bool): Whether to auto-scale the agent pool.
+            (default: :obj:`True`)
     """
 
     def __init__(
         self,
         description: str,
         worker: ChatAgent,
-        max_concurrent_tasks: int = 10,
+        use_agent_pool: bool = True,
+        pool_initial_size: int = 1,
+        pool_max_size: int = 10,
+        auto_scale_pool: bool = True,
     ) -> None:
         node_id = worker.agent_id
         super().__init__(
             description,
             node_id=node_id,
-            max_concurrent_tasks=max_concurrent_tasks,
         )
         self.worker = worker
+        self.use_agent_pool = use_agent_pool
+
+        self.agent_pool: Optional[AgentPool] = None
+        self._cleanup_task: Optional[asyncio.Task] = None
+        # Initialize agent pool if enabled
+        if self.use_agent_pool:
+            self.agent_pool = AgentPool(
+                base_agent=worker,
+                initial_size=pool_initial_size,
+                max_size=pool_max_size,
+                auto_scale=auto_scale_pool,
+            )
 
     def reset(self) -> Any:
         r"""Resets the worker to its initial state."""
         super().reset()
         self.worker.reset()
 
+        # Reset agent pool if it exists
+        if self.agent_pool:
+            # Stop cleanup task
+            if self._cleanup_task and not self._cleanup_task.done():
+                self._cleanup_task.cancel()
+
+            # Reinitialize pool
+            self.agent_pool = AgentPool(
+                base_agent=self.worker,
+            )
+
+    async def _get_worker_agent(self) -> ChatAgent:
+        r"""Get a worker agent, either from pool or by cloning."""
+        if self.use_agent_pool and self.agent_pool:
+            return await self.agent_pool.get_agent()
+        else:
+            # Fallback to original cloning approach
+            return self.worker.clone(with_memory=False)
+
+    async def _return_worker_agent(self, agent: ChatAgent) -> None:
+        r"""Return a worker agent to the pool if pooling is enabled."""
+        if self.use_agent_pool and self.agent_pool:
+            await self.agent_pool.return_agent(agent)
+        # If not using pool, agent will be garbage collected
+
     async def _process_task(
         self, task: Task, dependencies: List[Task]
     ) -> TaskState:
-        r"""Processes a task with its dependencies using a cloned agent.
+        r"""Processes a task with its dependencies using an efficient agent
+        management system.
 
         This method asynchronously processes a given task, considering its
-        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.
+        dependencies, by sending a generated prompt to a worker agent.
+        Uses an agent pool for efficiency when enabled, or falls back to
+        cloning when pool is disabled.
 
         Args:
             task (Task): The task to process, which includes necessary details
@@ -74,17 +270,17 @@ 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,
-            dependency_tasks_info=dependency_tasks_info,
-            additional_info=task.additional_info,
-        )
+        # Get agent efficiently (from pool or by cloning)
+        worker_agent = await self._get_worker_agent()
+
         try:
+            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,
+            )
+
             response = await worker_agent.astep(
                 prompt, response_format=TaskResult
             )
@@ -94,8 +290,11 @@ class SingleAgentWorker(Worker):
                 f"\n{e}{Fore.RESET}"
             )
             return TaskState.FAILED
+        finally:
+            # Return agent to pool or let it be garbage collected
+            await self._return_worker_agent(worker_agent)
 
-        # Get actual token usage from the cloned agent that processed this task
+        # Get actual token usage from the agent that processed this task
         try:
             _, total_token_count = worker_agent.memory.get_context()
         except Exception:
@@ -117,11 +316,11 @@ class SingleAgentWorker(Worker):
             "timestamp": str(datetime.datetime.now()),
             "description": f"Attempt by "
             f"{getattr(worker_agent, 'agent_id', worker_agent.role_name)} "
-            f"(cloned from "
+            f"(from pool/clone of "
             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"],
+            "tool_calls": response.info.get("tool_calls"),
             "total_token_count": total_token_count,
         }
 
@@ -157,3 +356,34 @@ class SingleAgentWorker(Worker):
 
         task.result = task_result.content
         return TaskState.DONE
+
+    async def _listen_to_channel(self):
+        r"""Override to start cleanup task when pool is enabled."""
+        # Start cleanup task for agent pool
+        if self.use_agent_pool and self.agent_pool:
+            self._cleanup_task = asyncio.create_task(self._periodic_cleanup())
+
+        # Call parent implementation
+        await super()._listen_to_channel()
+
+        # Stop cleanup task
+        if self._cleanup_task and not self._cleanup_task.done():
+            self._cleanup_task.cancel()
+
+    async def _periodic_cleanup(self):
+        r"""Periodically clean up idle agents from the pool."""
+        while True:
+            try:
+                await asyncio.sleep(60)  # Cleanup every minute
+                if self.agent_pool:
+                    await self.agent_pool.cleanup_idle_agents()
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                print(f"Error in pool cleanup: {e}")
+
+    def get_pool_stats(self) -> Optional[dict]:
+        r"""Get agent pool statistics if pool is enabled."""
+        if self.use_agent_pool and self.agent_pool:
+            return self.agent_pool.get_stats()
+        return None

camel/societies/workforce/utils.py

@@ -50,7 +50,8 @@ class TaskAssignment(BaseModel):
     )
     dependencies: List[str] = Field(
         default_factory=list,
-        description="List of task IDs that must complete before this task.",
+        description="List of task IDs that must complete before this task. "
+        "This is critical for the task decomposition and execution.",
     )
 
 
@@ -156,7 +157,14 @@ def check_if_running(
                 )
                 return None
             else:
-                raise last_exception
+                raise (
+                    last_exception
+                    if last_exception
+                    else RuntimeError(
+                        f"Unexpected failure in {func.__name__} "
+                        "with no exception captured."
+                    )
+                )
 
         return wrapper
 

camel/societies/workforce/worker.py

@@ -36,18 +36,14 @@ 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):
@@ -114,17 +110,12 @@ class Worker(BaseNode, ABC):
 
     @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.
+        r"""Continuously listen to the channel and process assigned tasks.
 
-        This method supports parallel task execution when multiple tasks
-        are assigned to the same worker.
+        This method supports parallel task execution without artificial limits.
         """
         self._running = True
-        logger.info(
-            f"{self} started with max {self.max_concurrent_tasks} "
-            f"concurrent tasks."
-        )
+        logger.info(f"{self} started.")
 
         # Keep track of running task coroutines
         running_tasks: Set[asyncio.Task] = set()
@@ -141,39 +132,24 @@ class Worker(BaseNode, ABC):
                     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}")
+                # Try to get a new task (with short timeout to avoid blocking)
+                try:
+                    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
 
             except Exception as e:
                 logger.error(

camel/societies/workforce/workforce.py

@@ -674,8 +674,8 @@ class Workforce(BaseNode):
             # Reset state for tasks being moved back to pending
             for task in tasks_to_move_back:
                 # Handle all possible task states
-                if task.state in [TaskState.DONE, TaskState.FAILED]:
-                    task.state = TaskState.OPEN
+                if task.state in [TaskState.DONE, TaskState.OPEN]:
+                    task.state = TaskState.FAILED  # TODO: Add logic for OPEN
                     # Clear result to avoid confusion
                     task.result = None
                     # Reset failure count to give task a fresh start
@@ -881,7 +881,7 @@ class Workforce(BaseNode):
         self.reset()
         self._task = task
         self._state = WorkforceState.RUNNING
-        task.state = TaskState.OPEN
+        task.state = TaskState.FAILED  # TODO: Add logic for OPEN
         self._pending_tasks.append(task)
 
         # Decompose the task into subtasks first
@@ -998,21 +998,23 @@ class Workforce(BaseNode):
         self,
         description: str,
         worker: ChatAgent,
-        max_concurrent_tasks: int = 10,
+        pool_max_size: int = 10,
     ) -> Workforce:
         r"""Add a worker node to the workforce that uses a single agent.
 
         Args:
             description (str): Description of the worker node.
             worker (ChatAgent): The agent to be added.
-            max_concurrent_tasks (int): Maximum number of tasks this worker can
-                process concurrently. (default: :obj:`10`)
+            pool_max_size (int): Maximum size of the agent pool.
+                (default: :obj:`10`)
 
         Returns:
             Workforce: The workforce node itself.
         """
         worker_node = SingleAgentWorker(
-            description, worker, max_concurrent_tasks
+            description=description,
+            worker=worker,
+            pool_max_size=pool_max_size,
         )
         self._children.append(worker_node)
         if self.metrics_logger:
@@ -1194,6 +1196,13 @@ class Workforce(BaseNode):
         response = self.coordinator_agent.step(
             prompt, response_format=TaskAssignResult
         )
+        if response.msg is None or response.msg.content is None:
+            logger.error(
+                "Coordinator agent returned empty response for task assignment"
+            )
+            # Return empty result as fallback
+            return TaskAssignResult(assignments=[])
+
         result_dict = json.loads(response.msg.content, parse_int=str)
         task_assign_result = TaskAssignResult(**result_dict)
         return task_assign_result
@@ -1231,8 +1240,21 @@ class Workforce(BaseNode):
         response = self.coordinator_agent.step(
             prompt, response_format=WorkerConf
         )
-        result_dict = json.loads(response.msg.content)
-        new_node_conf = WorkerConf(**result_dict)
+        if response.msg is None or response.msg.content is None:
+            logger.error(
+                "Coordinator agent returned empty response for worker creation"
+            )
+            # Create a fallback worker configuration
+            new_node_conf = WorkerConf(
+                description=f"Fallback worker for "
+                f"task: {task.content[:50]}...",
+                role="General Assistant",
+                sys_msg="You are a general assistant that can help "
+                "with various tasks.",
+            )
+        else:
+            result_dict = json.loads(response.msg.content)
+            new_node_conf = WorkerConf(**result_dict)
 
         new_agent = self._create_new_agent(
             new_node_conf.role,
@@ -1242,7 +1264,7 @@ class Workforce(BaseNode):
         new_node = SingleAgentWorker(
             description=new_node_conf.description,
             worker=new_agent,
-            max_concurrent_tasks=10,  # TODO: make this configurable
+            pool_max_size=10,  # TODO: make this configurable
         )
         new_node.set_channel(self._channel)
 
@@ -1384,10 +1406,10 @@ class Workforce(BaseNode):
                 metadata={'failure_count': task.failure_count},
             )
 
-        if task.failure_count >= 3:
+        if task.failure_count > 3:
             return True
 
-        if task.get_depth() >= 3:
+        if task.get_depth() > 3:
             # Create a new worker node and reassign
             assignee = self._create_worker_node_for_task(task)
 
@@ -1685,7 +1707,7 @@ class Workforce(BaseNode):
                     await self._graceful_shutdown(returned_task)
                     break
                 elif returned_task.state == TaskState.OPEN:
-                    # TODO: multi-layer workforce
+                    # TODO: Add logic for OPEN
                     pass
                 else:
                     raise ValueError(
@@ -1797,7 +1819,7 @@ class Workforce(BaseNode):
                 new_instance.add_single_agent_worker(
                     child.description,
                     cloned_worker,
-                    child.max_concurrent_tasks,
+                    pool_max_size=10,
                 )
             elif isinstance(child, RolePlayingWorker):
                 new_instance.add_role_playing_worker(
@@ -1808,7 +1830,6 @@ class Workforce(BaseNode):
                     child.user_agent_kwargs,
                     child.summarize_agent_kwargs,
                     child.chat_turn_limit,
-                    child.max_concurrent_tasks,
                 )
             elif isinstance(child, Workforce):
                 new_instance.add_workforce(child.clone(with_memory))