camel-ai 0.2.74a4__py3-none-any.whl → 0.2.75__py3-none-any.whl

camel/societies/workforce/task_channel.py

@@ -12,8 +12,9 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import asyncio
+from collections import defaultdict, deque
 from enum import Enum
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Set
 
 from camel.tasks import Task
 
@@ -79,27 +80,92 @@ class Packet:
 
 
 class TaskChannel:
-    r"""An internal class used by Workforce to manage tasks."""
+    r"""An internal class used by Workforce to manage tasks.
+
+    This implementation uses a hybrid data structure approach:
+    - Hash map (_task_dict) for O(1) task lookup by ID
+    - Status-based index (_task_by_status) for efficient filtering by status
+    - Assignee/publisher queues for ordered task processing
+    """
 
     def __init__(self) -> None:
         self._condition = asyncio.Condition()
         self._task_dict: Dict[str, Packet] = {}
 
+        self._task_by_status: Dict[PacketStatus, Set[str]] = defaultdict(set)
+
+        # task by assignee store which are sent to
+        self._task_by_assignee: Dict[str, deque[str]] = defaultdict(deque)
+
+        self._task_by_publisher: Dict[str, deque[str]] = defaultdict(deque)
+
+    def _update_task_status(
+        self, task_id: str, new_status: PacketStatus
+    ) -> None:
+        r"""Helper method to properly update task status in all indexes."""
+        if task_id not in self._task_dict:
+            return
+
+        packet = self._task_dict[task_id]
+        old_status = packet.status
+
+        if old_status in self._task_by_status:
+            self._task_by_status[old_status].discard(task_id)
+
+        packet.status = new_status
+
+        self._task_by_status[new_status].add(task_id)
+
+    def _cleanup_task_from_indexes(self, task_id: str) -> None:
+        r"""Helper method to remove a task from all indexes.
+
+        Args:
+            task_id (str): The ID of the task to remove from indexes.
+        """
+        if task_id not in self._task_dict:
+            return
+
+        packet = self._task_dict[task_id]
+
+        if packet.status in self._task_by_status:
+            self._task_by_status[packet.status].discard(task_id)
+
+        if packet.assignee_id and packet.assignee_id in self._task_by_assignee:
+            assignee_queue = self._task_by_assignee[packet.assignee_id]
+            self._task_by_assignee[packet.assignee_id] = deque(
+                task for task in assignee_queue if task != task_id
+            )
+
+        if packet.publisher_id in self._task_by_publisher:
+            publisher_queue = self._task_by_publisher[packet.publisher_id]
+            self._task_by_publisher[packet.publisher_id] = deque(
+                task for task in publisher_queue if task != task_id
+            )
+
     async def get_returned_task_by_publisher(self, publisher_id: str) -> Task:
         r"""Get a task from the channel that has been returned by the
         publisher.
         """
         async with self._condition:
             while True:
-                for task_id, packet in list(self._task_dict.items()):
-                    if packet.publisher_id != publisher_id:
-                        continue
-                    if packet.status != PacketStatus.RETURNED:
-                        continue
-                    # Remove the task to prevent returning it again
-                    del self._task_dict[task_id]
-                    self._condition.notify_all()
-                    return packet.task
+                task_ids = self._task_by_publisher[publisher_id]
+
+                if task_ids:
+                    task_id = task_ids.popleft()
+
+                    if task_id in self._task_dict:
+                        packet = self._task_dict[task_id]
+
+                        if (
+                            packet.status == PacketStatus.RETURNED
+                            and packet.publisher_id == publisher_id
+                        ):
+                            # Clean up all indexes before removing
+                            self._cleanup_task_from_indexes(task_id)
+                            del self._task_dict[task_id]
+                            self._condition.notify_all()
+                            return packet.task
+
                 await self._condition.wait()
 
     async def get_assigned_task_by_assignee(self, assignee_id: str) -> Task:
@@ -109,15 +175,26 @@ class TaskChannel:
         """
         async with self._condition:
             while True:
-                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
+                task_ids = self._task_by_assignee.get(assignee_id, deque())
+
+                # Process all available tasks until we find a valid one
+                while task_ids:
+                    task_id = task_ids.popleft()
+
+                    if task_id in self._task_dict:
+                        packet = self._task_dict[task_id]
+
+                        if (
+                            packet.status == PacketStatus.SENT
+                            and packet.assignee_id == assignee_id
+                        ):
+                            # Use helper method to properly update status
+                            self._update_task_status(
+                                task_id, PacketStatus.PROCESSING
+                            )
+                            self._condition.notify_all()
+                            return packet.task
+
                 await self._condition.wait()
 
     async def post_task(
@@ -128,6 +205,8 @@ class TaskChannel:
         async with self._condition:
             packet = Packet(task, publisher_id, assignee_id)
             self._task_dict[packet.task.id] = packet
+            self._task_by_status[PacketStatus.SENT].add(packet.task.id)
+            self._task_by_assignee[assignee_id].append(packet.task.id)
             self._condition.notify_all()
 
     async def post_dependency(
@@ -140,6 +219,7 @@ class TaskChannel:
                 dependency, publisher_id, status=PacketStatus.ARCHIVED
             )
             self._task_dict[packet.task.id] = packet
+            self._task_by_status[PacketStatus.ARCHIVED].add(packet.task.id)
             self._condition.notify_all()
 
     async def return_task(self, task_id: str) -> None:
@@ -148,7 +228,12 @@ class TaskChannel:
         async with self._condition:
             if task_id in self._task_dict:
                 packet = self._task_dict[task_id]
-                packet.status = PacketStatus.RETURNED
+                # Only add to publisher queue if not already returned
+                if packet.status != PacketStatus.RETURNED:
+                    self._update_task_status(task_id, PacketStatus.RETURNED)
+                    self._task_by_publisher[packet.publisher_id].append(
+                        packet.task.id
+                    )
             self._condition.notify_all()
 
     async def archive_task(self, task_id: str) -> None:
@@ -156,7 +241,17 @@ class TaskChannel:
         async with self._condition:
             if task_id in self._task_dict:
                 packet = self._task_dict[task_id]
-                packet.status = PacketStatus.ARCHIVED
+                # Remove from assignee queue before archiving
+                if (
+                    packet.assignee_id
+                    and packet.assignee_id in self._task_by_assignee
+                ):
+                    assignee_queue = self._task_by_assignee[packet.assignee_id]
+                    self._task_by_assignee[packet.assignee_id] = deque(
+                        task for task in assignee_queue if task != task_id
+                    )
+                # Update status (keeps in status index for dependencies)
+                self._update_task_status(task_id, PacketStatus.ARCHIVED)
             self._condition.notify_all()
 
     async def remove_task(self, task_id: str) -> None:
@@ -164,17 +259,15 @@ class TaskChannel:
         async with self._condition:
             # Check if task ID exists before removing
             if task_id in self._task_dict:
+                # Clean up all indexes before removing
+                self._cleanup_task_from_indexes(task_id)
                 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, packet in self._task_dict.items():
-                if packet.status == PacketStatus.ARCHIVED:
-                    dependency_ids.append(task_id)
-            return dependency_ids
+            return list(self._task_by_status[PacketStatus.ARCHIVED])
 
     async def get_task_by_id(self, task_id: str) -> Task:
         r"""Get a task from the channel by its ID."""

camel/societies/workforce/workforce.py

@@ -84,7 +84,7 @@ logger = get_logger(__name__)
 # Constants for configuration values
 MAX_TASK_RETRIES = 3
 MAX_PENDING_TASKS_LIMIT = 20
-TASK_TIMEOUT_SECONDS = 480.0
+TASK_TIMEOUT_SECONDS = 600.0
 DEFAULT_WORKER_POOL_SIZE = 10
 
 
@@ -1497,6 +1497,9 @@ class Workforce(BaseNode):
                         start_coroutine, self._loop
                     )
                 self._child_listening_tasks.append(child_task)
+            else:
+                # Close the coroutine to prevent RuntimeWarning
+                start_coroutine.close()
         else:
             # Close the coroutine to prevent RuntimeWarning
             start_coroutine.close()
@@ -2310,6 +2313,9 @@ class Workforce(BaseNode):
         r"""Get the task that's published by this node and just get returned
         from the assignee. Includes timeout handling to prevent indefinite
         waiting.
+
+        Raises:
+            asyncio.TimeoutError: If waiting for task exceeds timeout
         """
         try:
             # Add timeout to prevent indefinite waiting
@@ -2317,6 +2323,17 @@ class Workforce(BaseNode):
                 self._channel.get_returned_task_by_publisher(self.node_id),
                 timeout=self.task_timeout_seconds,
             )
+        except asyncio.TimeoutError:
+            # Re-raise timeout errors to be handled by caller
+            # This prevents hanging when tasks are stuck
+            logger.warning(
+                f"Timeout waiting for task return in workforce "
+                f"{self.node_id}. "
+                f"Timeout: {self.task_timeout_seconds}s, "
+                f"Pending tasks: {len(self._pending_tasks)}, "
+                f"In-flight tasks: {self._in_flight_tasks}"
+            )
+            raise
         except Exception as e:
             error_msg = (
                 f"Error getting returned task {e} in "
@@ -2835,9 +2852,24 @@ class Workforce(BaseNode):
                         self._last_snapshot_time = time.time()
 
                 # Get returned task
-                returned_task = await self._get_returned_task()
+                try:
+                    returned_task = await self._get_returned_task()
+                except asyncio.TimeoutError:
+                    # Handle timeout - check if we have tasks stuck in flight
+                    if self._in_flight_tasks > 0:
+                        logger.warning(
+                            f"Timeout waiting for {self._in_flight_tasks} "
+                            f"in-flight tasks. Breaking to prevent hanging."
+                        )
+                        # Break the loop to prevent indefinite hanging
+                        # The finally block will handle cleanup
+                        break
+                    else:
+                        # No tasks in flight, safe to continue
+                        await self._post_ready_tasks()
+                        continue
 
-                # If no task was returned, continue
+                # If no task was returned (other errors), continue
                 if returned_task is None:
                     logger.debug(
                         f"No task returned in workforce {self.node_id}. "

camel/toolkits/__init__.py

@@ -68,7 +68,6 @@ from .pubmed_toolkit import PubMedToolkit
 from .data_commons_toolkit import DataCommonsToolkit
 from .thinking_toolkit import ThinkingToolkit
 from .pyautogui_toolkit import PyAutoGUIToolkit
-from .openai_agent_toolkit import OpenAIAgentToolkit
 from .searxng_toolkit import SearxNGToolkit
 from .jina_reranker_toolkit import JinaRerankerToolkit
 from .pulse_mcp_search_toolkit import PulseMCPSearchToolkit
@@ -143,7 +142,6 @@ __all__ = [
     'DataCommonsToolkit',
     'ThinkingToolkit',
     'PyAutoGUIToolkit',
-    'OpenAIAgentToolkit',
     'SearxNGToolkit',
     'JinaRerankerToolkit',
     'OrigeneToolkit',

camel/toolkits/github_toolkit.py

@@ -14,6 +14,7 @@
 
 import logging
 import os
+import warnings
 from typing import Dict, List, Literal, Optional, Union
 
 from camel.toolkits import FunctionTool
@@ -80,7 +81,7 @@ class GithubToolkit(BaseToolkit):
             )
         return GITHUB_ACCESS_TOKEN
 
-    def create_pull_request(
+    def github_create_pull_request(
         self,
         repo_name: str,
         file_path: str,
@@ -150,7 +151,7 @@ class GithubToolkit(BaseToolkit):
         else:
             raise ValueError("PRs with multiple files aren't supported yet.")
 
-    def get_issue_list(
+    def github_get_issue_list(
         self, repo_name: str, state: Literal["open", "closed", "all"] = "all"
     ) -> List[Dict[str, object]]:
         r"""Retrieves all issues from the GitHub repository.
@@ -177,7 +178,9 @@ class GithubToolkit(BaseToolkit):
 
         return issues_info
 
-    def get_issue_content(self, repo_name: str, issue_number: int) -> str:
+    def github_get_issue_content(
+        self, repo_name: str, issue_number: int
+    ) -> str:
         r"""Retrieves the content of a specific issue by its number.
 
         Args:
@@ -194,7 +197,7 @@ class GithubToolkit(BaseToolkit):
         except Exception as e:
             return f"can't get Issue number {issue_number}: {e!s}"
 
-    def get_pull_request_list(
+    def github_get_pull_request_list(
         self, repo_name: str, state: Literal["open", "closed", "all"] = "all"
     ) -> List[Dict[str, object]]:
         r"""Retrieves all pull requests from the GitHub repository.
@@ -221,7 +224,7 @@ class GithubToolkit(BaseToolkit):
 
         return pull_requests_info
 
-    def get_pull_request_code(
+    def github_get_pull_request_code(
         self, repo_name: str, pr_number: int
     ) -> List[Dict[str, str]]:
         r"""Retrieves the code changes of a specific pull request.
@@ -253,7 +256,7 @@ class GithubToolkit(BaseToolkit):
 
         return files_changed
 
-    def get_pull_request_comments(
+    def github_get_pull_request_comments(
         self, repo_name: str, pr_number: int
     ) -> List[Dict[str, str]]:
         r"""Retrieves the comments from a specific pull request.
@@ -278,7 +281,9 @@ class GithubToolkit(BaseToolkit):
 
         return comments
 
-    def get_all_file_paths(self, repo_name: str, path: str = "") -> List[str]:
+    def github_get_all_file_paths(
+        self, repo_name: str, path: str = ""
+    ) -> List[str]:
         r"""Recursively retrieves all file paths in the GitHub repository.
 
         Args:
@@ -308,13 +313,15 @@ class GithubToolkit(BaseToolkit):
             for content in contents:
                 if content.type == "dir":
                     # If it's a directory, recursively retrieve its file paths
-                    files.extend(self.get_all_file_paths(content.path))
+                    files.extend(self.github_get_all_file_paths(content.path))
                 else:
                     # If it's a file, add its path to the list
                     files.append(content.path)
         return files
 
-    def retrieve_file_content(self, repo_name: str, file_path: str) -> str:
+    def github_retrieve_file_content(
+        self, repo_name: str, file_path: str
+    ) -> str:
         r"""Retrieves the content of a file from the GitHub repository.
 
         Args:
@@ -343,12 +350,92 @@ class GithubToolkit(BaseToolkit):
                 the functions in the toolkit.
         """
         return [
-            FunctionTool(self.create_pull_request),
-            FunctionTool(self.get_issue_list),
-            FunctionTool(self.get_issue_content),
-            FunctionTool(self.get_pull_request_list),
-            FunctionTool(self.get_pull_request_code),
-            FunctionTool(self.get_pull_request_comments),
-            FunctionTool(self.get_all_file_paths),
-            FunctionTool(self.retrieve_file_content),
+            FunctionTool(self.github_create_pull_request),
+            FunctionTool(self.github_get_issue_list),
+            FunctionTool(self.github_get_issue_content),
+            FunctionTool(self.github_get_pull_request_list),
+            FunctionTool(self.github_get_pull_request_code),
+            FunctionTool(self.github_get_pull_request_comments),
+            FunctionTool(self.github_get_all_file_paths),
+            FunctionTool(self.github_retrieve_file_content),
         ]
+
+    # Deprecated method aliases for backward compatibility
+    def create_pull_request(self, *args, **kwargs):
+        r"""Deprecated: Use github_create_pull_request instead."""
+        warnings.warn(
+            "create_pull_request is deprecated. Use "
+            "github_create_pull_request instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.github_create_pull_request(*args, **kwargs)
+
+    def get_issue_list(self, *args, **kwargs):
+        r"""Deprecated: Use github_get_issue_list instead."""
+        warnings.warn(
+            "get_issue_list is deprecated. Use github_get_issue_list instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.github_get_issue_list(*args, **kwargs)
+
+    def get_issue_content(self, *args, **kwargs):
+        r"""Deprecated: Use github_get_issue_content instead."""
+        warnings.warn(
+            "get_issue_content is deprecated. Use "
+            "github_get_issue_content instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.github_get_issue_content(*args, **kwargs)
+
+    def get_pull_request_list(self, *args, **kwargs):
+        r"""Deprecated: Use github_get_pull_request_list instead."""
+        warnings.warn(
+            "get_pull_request_list is deprecated. "
+            "Use github_get_pull_request_list instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.github_get_pull_request_list(*args, **kwargs)
+
+    def get_pull_request_code(self, *args, **kwargs):
+        r"""Deprecated: Use github_get_pull_request_code instead."""
+        warnings.warn(
+            "get_pull_request_code is deprecated. Use "
+            "github_get_pull_request_code instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.github_get_pull_request_code(*args, **kwargs)
+
+    def get_pull_request_comments(self, *args, **kwargs):
+        r"""Deprecated: Use github_get_pull_request_comments instead."""
+        warnings.warn(
+            "get_pull_request_comments is deprecated. "
+            "Use github_get_pull_request_comments instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.github_get_pull_request_comments(*args, **kwargs)
+
+    def get_all_file_paths(self, *args, **kwargs):
+        r"""Deprecated: Use github_get_all_file_paths instead."""
+        warnings.warn(
+            "get_all_file_paths is deprecated. Use "
+            "github_get_all_file_paths instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.github_get_all_file_paths(*args, **kwargs)
+
+    def retrieve_file_content(self, *args, **kwargs):
+        r"""Deprecated: Use github_retrieve_file_content instead."""
+        warnings.warn(
+            "retrieve_file_content is deprecated. "
+            "Use github_retrieve_file_content instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.github_retrieve_file_content(*args, **kwargs)

camel/toolkits/hybrid_browser_toolkit/config_loader.py

@@ -23,6 +23,7 @@ class BrowserConfig:
     headless: bool = True
     user_data_dir: Optional[str] = None
     stealth: bool = False
+    console_log_limit: int = 1000
 
     # Default settings
     default_start_url: str = "https://google.com/"
@@ -105,6 +106,8 @@ class ConfigLoader:
                 browser_kwargs["connect_over_cdp"] = value
             elif key == "cdpUrl":
                 browser_kwargs["cdp_url"] = value
+            elif key == "consoleLogLimit":
+                browser_kwargs["console_log_limit"] = value
             elif key == "cacheDir":
                 toolkit_kwargs["cache_dir"] = value
             elif key == "browserLogToFile":