camel-ai 0.2.71a7__tar.gz → 0.2.71a8__tar.gz

{camel_ai-0.2.71a7 → camel_ai-0.2.71a8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.71a7
+Version: 0.2.71a8
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel

{camel_ai-0.2.71a7 → camel_ai-0.2.71a8}/camel/__init__.py

@@ -14,7 +14,7 @@
 
 from camel.logger import disable_logging, enable_logging, set_log_level
 
-__version__ = '0.2.71a7'
+__version__ = '0.2.71a8'
 
 __all__ = [
     '__version__',

{camel_ai-0.2.71a7 → camel_ai-0.2.71a8}/camel/societies/workforce/task_channel.py

@@ -91,11 +91,14 @@ class TaskChannel:
         """
         async with self._condition:
             while True:
-                for packet in self._task_dict.values():
+                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
                 await self._condition.wait()
 

{camel_ai-0.2.71a7 → camel_ai-0.2.71a8}/camel/societies/workforce/workforce.py

@@ -551,6 +551,10 @@ class Workforce(BaseNode):
                     continue
 
             if not memory_records:
+                logger.warning(
+                    "No valid memory records could be reconstructed "
+                    "for sharing"
+                )
                 return
 
             # Share with coordinator agent
@@ -668,6 +672,12 @@ class Workforce(BaseNode):
         if task_id in self._task_start_times:
             del self._task_start_times[task_id]
 
+        if task_id in self._task_dependencies:
+            del self._task_dependencies[task_id]
+
+        if task_id in self._assignees:
+            del self._assignees[task_id]
+
     def _decompose_task(self, task: Task) -> List[Task]:
         r"""Decompose the task into subtasks. This method will also set the
         relationship between the task and its subtasks.
@@ -991,8 +1001,13 @@ class Workforce(BaseNode):
         tasks_dict = {task.id: task for task in self._pending_tasks}
 
         # Check if all provided IDs exist
-        if not all(task_id in tasks_dict for task_id in task_ids):
-            logger.warning("Some task IDs not found in pending tasks.")
+        invalid_ids = [
+            task_id for task_id in task_ids if task_id not in tasks_dict
+        ]
+        if invalid_ids:
+            logger.warning(
+                f"Task IDs not found in pending tasks: {invalid_ids}"
+            )
             return False
 
         # Check if we have the same number of tasks
@@ -2057,7 +2072,6 @@ class Workforce(BaseNode):
                     logger.error(
                         f"JSON parsing error in worker creation: Invalid "
                         f"response format - {e}. Response content: "
-                        f"format - {e}. Response content: "
                         f"{response.msg.content[:100]}..."
                     )
                     raise RuntimeError(

{camel_ai-0.2.71a7 → camel_ai-0.2.71a8}/camel/toolkits/file_write_toolkit.py

@@ -11,6 +11,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+import os
 import re
 from datetime import datetime
 from pathlib import Path
@@ -37,7 +38,7 @@ class FileWriteToolkit(BaseToolkit):
 
     def __init__(
         self,
-        output_dir: str = "./",
+        working_directory: Optional[str] = None,
         timeout: Optional[float] = None,
         default_encoding: str = "utf-8",
         backup_enabled: bool = True,
@@ -45,8 +46,11 @@ class FileWriteToolkit(BaseToolkit):
         r"""Initialize the FileWriteToolkit.
 
         Args:
-            output_dir (str): The default directory for output files.
-                Defaults to the current working directory.
+            working_directory (str, optional): The default directory for
+                output files. If not provided, it will be determined by the
+                `CAMEL_WORKDIR` environment variable (if set). If the
+                environment variable is not set, it defaults to
+                `camel_working_dir`.
             timeout (Optional[float]): The timeout for the toolkit.
                 (default: :obj:`None`)
             default_encoding (str): Default character encoding for text
@@ -55,13 +59,20 @@ class FileWriteToolkit(BaseToolkit):
                 before overwriting. (default: :obj:`True`)
         """
         super().__init__(timeout=timeout)
-        self.output_dir = Path(output_dir).resolve()
-        self.output_dir.mkdir(parents=True, exist_ok=True)
+        if working_directory:
+            self.working_directory = Path(working_directory).resolve()
+        else:
+            camel_workdir = os.environ.get("CAMEL_WORKDIR")
+            if camel_workdir:
+                self.working_directory = Path(camel_workdir).resolve()
+            else:
+                self.working_directory = Path("./camel_working_dir").resolve()
+        self.working_directory.mkdir(parents=True, exist_ok=True)
         self.default_encoding = default_encoding
         self.backup_enabled = backup_enabled
         logger.info(
             f"FileWriteToolkit initialized with output directory"
-            f": {self.output_dir}, encoding: {default_encoding}"
+            f": {self.working_directory}, encoding: {default_encoding}"
         )
 
     def _resolve_filepath(self, file_path: str) -> Path:
@@ -80,7 +91,7 @@ class FileWriteToolkit(BaseToolkit):
         """
         path_obj = Path(file_path)
         if not path_obj.is_absolute():
-            path_obj = self.output_dir / path_obj
+            path_obj = self.working_directory / path_obj
 
         sanitized_filename = self._sanitize_filename(path_obj.name)
         path_obj = path_obj.parent / sanitized_filename
@@ -916,7 +927,7 @@ class FileWriteToolkit(BaseToolkit):
                 - CSV: string or list of lists
                 - JSON: string or serializable object
             filename (str): The name or path of the file. If a relative path is
-                supplied, it is resolved to self.output_dir.
+                supplied, it is resolved to self.working_directory.
             encoding (Optional[str]): The character encoding to use. (default:
                 :obj: `None`)
             use_latex (bool): Whether to use LaTeX for math rendering.

{camel_ai-0.2.71a7 → camel_ai-0.2.71a8}/camel/toolkits/hybrid_browser_toolkit/actions.py

@@ -14,6 +14,8 @@
 import asyncio
 from typing import TYPE_CHECKING, Any, Dict, Optional
 
+from .config_loader import ConfigLoader
+
 if TYPE_CHECKING:
     from playwright.async_api import Page
 
@@ -21,15 +23,24 @@ if TYPE_CHECKING:
 class ActionExecutor:
     r"""Executes high-level actions (click, type …) on a Playwright Page."""
 
-    # Configuration constants
-    DEFAULT_TIMEOUT = 5000  # 5 seconds
-    SHORT_TIMEOUT = 2000  # 2 seconds
-    MAX_SCROLL_AMOUNT = 5000  # Maximum scroll distance in pixels
-
-    def __init__(self, page: "Page", session: Optional[Any] = None):
+    def __init__(
+        self,
+        page: "Page",
+        session: Optional[Any] = None,
+        default_timeout: Optional[int] = None,
+        short_timeout: Optional[int] = None,
+        max_scroll_amount: Optional[int] = None,
+    ):
         self.page = page
         self.session = session  # HybridBrowserSession instance
 
+        # Configure timeouts using the config file with optional overrides
+        self.default_timeout = ConfigLoader.get_action_timeout(default_timeout)
+        self.short_timeout = ConfigLoader.get_short_timeout(short_timeout)
+        self.max_scroll_amount = ConfigLoader.get_max_scroll_amount(
+            max_scroll_amount
+        )
+
     # ------------------------------------------------------------------
     # Public helpers
     # ------------------------------------------------------------------
@@ -139,7 +150,7 @@ class ActionExecutor:
         try:
             if self.session:
                 async with self.page.context.expect_page(
-                    timeout=self.SHORT_TIMEOUT
+                    timeout=self.short_timeout
                 ) as new_page_info:
                     await element.click(modifiers=["ControlOrMeta"])
                 new_page = await new_page_info.value
@@ -188,7 +199,7 @@ class ActionExecutor:
 
         # Fallback to normal force click if ctrl+click fails
         try:
-            await element.click(force=True, timeout=self.DEFAULT_TIMEOUT)
+            await element.click(force=True, timeout=self.default_timeout)
             details["click_method"] = "playwright_force_click"
             return {
                 "message": f"Fallback clicked element: {found_selector}",
@@ -224,7 +235,7 @@ class ActionExecutor:
         }
 
         try:
-            await self.page.fill(target, text, timeout=self.SHORT_TIMEOUT)
+            await self.page.fill(target, text, timeout=self.short_timeout)
             return {
                 "message": f"Typed '{text}' into {target}",
                 "details": details,
@@ -254,7 +265,7 @@ class ActionExecutor:
 
         try:
             await self.page.select_option(
-                target, value, timeout=self.DEFAULT_TIMEOUT
+                target, value, timeout=self.default_timeout
             )
             return {
                 "message": f"Selected '{value}' in {target}",
@@ -283,7 +294,7 @@ class ActionExecutor:
             details["wait_type"] = "selector"
             details["selector"] = sel
             await self.page.wait_for_selector(
-                sel, timeout=self.DEFAULT_TIMEOUT
+                sel, timeout=self.default_timeout
             )
             return {"message": f"Waited for {sel}", "details": details}
         return {
@@ -303,7 +314,7 @@ class ActionExecutor:
         target = f"[aria-ref='{ref}']"
         details = {"ref": ref, "target": target}
 
-        await self.page.wait_for_selector(target, timeout=self.DEFAULT_TIMEOUT)
+        await self.page.wait_for_selector(target, timeout=self.default_timeout)
         txt = await self.page.text_content(target)
 
         details["extracted_text"] = txt
@@ -337,9 +348,9 @@ class ActionExecutor:
             # Safely convert amount to integer and clamp to reasonable range
             amount_int = int(amount)
             amount_int = max(
-                -self.MAX_SCROLL_AMOUNT,
-                min(self.MAX_SCROLL_AMOUNT, amount_int),
-            )  # Clamp to MAX_SCROLL_AMOUNT range
+                -self.max_scroll_amount,
+                min(self.max_scroll_amount, amount_int),
+            )  # Clamp to max_scroll_amount range
             details["actual_amount"] = amount_int
         except (ValueError, TypeError):
             return {
@@ -366,7 +377,6 @@ class ActionExecutor:
 
         # Press Enter on whatever element currently has focus
         await self.page.keyboard.press("Enter")
-        await asyncio.sleep(0.3)
         return {
             "message": "Pressed Enter on focused element",
             "details": details,
@@ -378,13 +388,13 @@ class ActionExecutor:
         try:
             # Wait for basic DOM content loading
             await self.page.wait_for_load_state(
-                'domcontentloaded', timeout=self.SHORT_TIMEOUT
+                'domcontentloaded', timeout=self.short_timeout
             )
 
             # Try to wait for network idle briefly
             try:
                 await self.page.wait_for_load_state(
-                    'networkidle', timeout=self.SHORT_TIMEOUT
+                    'networkidle', timeout=self.short_timeout
                 )
             except Exception:
                 pass  # Network idle is optional

{camel_ai-0.2.71a7 → camel_ai-0.2.71a8}/camel/toolkits/hybrid_browser_toolkit/agent.py

@@ -81,9 +81,15 @@ what was accomplished
         headless: bool = False,
         stealth: bool = False,
         model_backend: Optional[BaseModelBackend] = None,
+        default_timeout: Optional[int] = None,
+        short_timeout: Optional[int] = None,
     ):
         self._session = HybridBrowserSession(
-            headless=headless, user_data_dir=user_data_dir, stealth=stealth
+            headless=headless,
+            user_data_dir=user_data_dir,
+            stealth=stealth,
+            default_timeout=default_timeout,
+            short_timeout=short_timeout,
         )
         from camel.agents import ChatAgent
 

{camel_ai-0.2.71a7 → camel_ai-0.2.71a8}/camel/toolkits/hybrid_browser_toolkit/browser_session.py

@@ -19,8 +19,8 @@ from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Tuple
 from camel.logger import get_logger
 
 from .actions import ActionExecutor
+from .config_loader import ConfigLoader
 from .snapshot import PageSnapshot
-from .stealth_config import StealthConfig
 
 if TYPE_CHECKING:
     from playwright.async_api import (
@@ -44,10 +44,6 @@ class HybridBrowserSession:
     This class is a singleton per event-loop and session-id combination.
     """
 
-    # Configuration constants
-    DEFAULT_NAVIGATION_TIMEOUT = 10000  # 10 seconds
-    NETWORK_IDLE_TIMEOUT = 5000  # 5 seconds
-
     # Class-level registry for singleton instances
     # Format: {(loop_id, session_id): HybridBrowserSession}
     _instances: ClassVar[Dict[Tuple[Any, str], "HybridBrowserSession"]] = {}
@@ -63,6 +59,10 @@ class HybridBrowserSession:
         user_data_dir: Optional[str] = None,
         stealth: bool = False,
         session_id: Optional[str] = None,
+        default_timeout: Optional[int] = None,
+        short_timeout: Optional[int] = None,
+        navigation_timeout: Optional[int] = None,
+        network_idle_timeout: Optional[int] = None,
     ) -> "HybridBrowserSession":
         # Create a unique key for this event loop and session combination
         # We defer the event loop lookup to avoid issues with creation
@@ -75,6 +75,10 @@ class HybridBrowserSession:
             "user_data_dir": user_data_dir,
             "stealth": stealth,
             "session_id": session_id,
+            "default_timeout": default_timeout,
+            "short_timeout": short_timeout,
+            "navigation_timeout": navigation_timeout,
+            "network_idle_timeout": network_idle_timeout,
         }
         return instance
 
@@ -126,6 +130,10 @@ class HybridBrowserSession:
         user_data_dir: Optional[str] = None,
         stealth: bool = False,
         session_id: Optional[str] = None,
+        default_timeout: Optional[int] = None,
+        short_timeout: Optional[int] = None,
+        navigation_timeout: Optional[int] = None,
+        network_idle_timeout: Optional[int] = None,
     ):
         if self._initialized:
             return
@@ -136,12 +144,27 @@ class HybridBrowserSession:
         self._stealth = stealth
         self._session_id = session_id or "default"
 
+        # Store timeout configuration for ActionExecutor instances and
+        # browser operations
+        self._default_timeout = default_timeout
+        self._short_timeout = short_timeout
+        self._navigation_timeout = ConfigLoader.get_navigation_timeout(
+            navigation_timeout
+        )
+        self._network_idle_timeout = ConfigLoader.get_network_idle_timeout(
+            network_idle_timeout
+        )
+
         # Initialize _creation_params to fix linter error
         self._creation_params = {
             "headless": headless,
             "user_data_dir": user_data_dir,
             "stealth": stealth,
             "session_id": session_id,
+            "default_timeout": default_timeout,
+            "short_timeout": short_timeout,
+            "navigation_timeout": navigation_timeout,
+            "network_idle_timeout": network_idle_timeout,
         }
 
         self._playwright: Optional[Playwright] = None
@@ -164,7 +187,8 @@ class HybridBrowserSession:
         self._stealth_config: Optional[Dict[str, Any]] = None
         if self._stealth:
             self._stealth_script = self._load_stealth_script()
-            self._stealth_config = StealthConfig.get_all_config()
+            stealth_config_class = ConfigLoader.get_stealth_config()
+            self._stealth_config = stealth_config_class.get_stealth_config()
 
     def _load_stealth_script(self) -> str:
         r"""Load the stealth JavaScript script from file."""
@@ -231,9 +255,7 @@ class HybridBrowserSession:
         # Navigate if URL provided
         if url:
             try:
-                await new_page.goto(
-                    url, timeout=self.DEFAULT_NAVIGATION_TIMEOUT
-                )
+                await new_page.goto(url, timeout=self._navigation_timeout)
                 await new_page.wait_for_load_state('domcontentloaded')
             except Exception as e:
                 logger.warning(f"Failed to navigate new tab to {url}: {e}")
@@ -319,7 +341,12 @@ class HybridBrowserSession:
             await self._page.bring_to_front()
 
             # Update executor and snapshot for new tab
-            self.executor = ActionExecutor(self._page, self)
+            self.executor = ActionExecutor(
+                self._page,
+                self,
+                default_timeout=self._default_timeout,
+                short_timeout=self._short_timeout,
+            )
             self.snapshot = PageSnapshot(self._page)
 
             logger.info(f"Switched to tab {tab_index}")
@@ -506,14 +533,17 @@ class HybridBrowserSession:
                 logger.warning(f"Failed to apply stealth script: {e}")
 
         # Set up timeout for navigation
-        self._page.set_default_navigation_timeout(
-            self.DEFAULT_NAVIGATION_TIMEOUT
-        )
-        self._page.set_default_timeout(self.DEFAULT_NAVIGATION_TIMEOUT)
+        self._page.set_default_navigation_timeout(self._navigation_timeout)
+        self._page.set_default_timeout(self._navigation_timeout)
 
         # Initialize utilities
         self.snapshot = PageSnapshot(self._page)
-        self.executor = ActionExecutor(self._page, self)
+        self.executor = ActionExecutor(
+            self._page,
+            self,
+            default_timeout=self._default_timeout,
+            short_timeout=self._short_timeout,
+        )
         self._current_tab_index = 0
 
         logger.info("Browser session initialized successfully")
@@ -579,7 +609,7 @@ class HybridBrowserSession:
                         await page.close()
                         logger.debug(
                             f"Closed page: "
-                            f"{page.url if hasattr(page, 'url') else 'unknown'}"  # noqa: E501
+                            f"{page.url if hasattr(page, 'url') else 'unknown'}"  # noqa:E501
                         )
                 except Exception as e:
                     logger.warning(f"Error closing page: {e}")
@@ -668,13 +698,13 @@ class HybridBrowserSession:
         await self.ensure_browser()
         page = await self.get_page()
 
-        await page.goto(url, timeout=self.DEFAULT_NAVIGATION_TIMEOUT)
+        await page.goto(url, timeout=self._navigation_timeout)
         await page.wait_for_load_state('domcontentloaded')
 
         # Try to wait for network idle
         try:
             await page.wait_for_load_state(
-                'networkidle', timeout=self.NETWORK_IDLE_TIMEOUT
+                'networkidle', timeout=self._network_idle_timeout
             )
         except Exception:
             logger.debug("Network idle timeout - continuing anyway")