camel-ai 0.2.64__py3-none-any.whl → 0.2.65__py3-none-any.whl

camel/societies/workforce/utils.py

@@ -16,6 +16,10 @@ from typing import Callable
 
 from pydantic import BaseModel, Field
 
+from camel.logger import get_logger
+
+logger = get_logger(__name__)
+
 
 class WorkerConf(BaseModel):
     r"""The configuration of a worker."""
@@ -71,3 +75,50 @@ def check_if_running(running: bool) -> Callable:
         return wrapper
 
     return decorator
+
+
+def validate_task_content(
+    content: str, task_id: str = "unknown", min_length: int = 10
+) -> bool:
+    r"""Validates task result content to avoid silent failures.
+    It performs basic checks to ensure the content meets minimum
+    quality standards.
+
+    Args:
+        content (str): The task result content to validate.
+        task_id (str): Task ID for logging purposes.
+            (default: :obj:`"unknown"`)
+        min_length (int): Minimum content length after stripping whitespace.
+            (default: :obj:`10`)
+
+    Returns:
+        bool: True if content passes validation, False otherwise.
+    """
+    # 1: Content must not be None
+    if content is None:
+        logger.warning(f"Task {task_id}: None content rejected")
+        return False
+
+    # 2: Content must not be empty after stripping whitespace
+    stripped_content = content.strip()
+    if not stripped_content:
+        logger.warning(
+            f"Task {task_id}: Empty or whitespace-only content rejected."
+        )
+        return False
+
+    # 3: Content must meet minimum meaningful length
+    if len(stripped_content) < min_length:
+        logger.warning(
+            f"Task {task_id}: Content too short ({len(stripped_content)} "
+            f"chars < {min_length} minimum). Content preview: "
+            f"'{stripped_content[:50]}...'"
+        )
+        return False
+
+    # All validation checks passed
+    logger.debug(
+        f"Task {task_id}: Content validation passed "
+        f"({len(stripped_content)} chars)"
+    )
+    return True

camel/societies/workforce/workforce.py

@@ -681,8 +681,8 @@ class Workforce(BaseNode):
                 task_id (str, optional): Unique identifier for the task. If
                     None, a UUID will be automatically generated.
                     (default: :obj:`None`)
-                additional_info (str, optional): Additional information or
-                    context for the task. (default: :obj:`None`)
+                additional_info (Optional[Dict[str, Any]]): Additional
+                    information or context for the task. (default: :obj:`None`)
 
             Returns:
                 Dict[str, Any]: A dictionary containing the processing result
@@ -701,7 +701,7 @@ class Workforce(BaseNode):
             task = Task(
                 content=task_content,
                 id=task_id or str(uuid.uuid4()),
-                additional_info=additional_info or "",
+                additional_info=additional_info,
             )
 
             try:

camel/tasks/task.py

@@ -106,6 +106,14 @@ class Task(BaseModel):
 
     additional_info: Optional[Dict[str, Any]] = None
 
+    def __repr__(self) -> str:
+        r"""Return a string representation of the task."""
+        content_preview = self.content
+        return (
+            f"Task(id='{self.id}', content='{content_preview}', "
+            f"state='{self.state.value}')"
+        )
+
     @classmethod
     def from_message(cls, message: BaseMessage) -> "Task":
         r"""Create a task from a message.

camel/toolkits/async_browser_toolkit.py

@@ -123,6 +123,7 @@ class AsyncBaseBrowser:
         cache_dir: Optional[str] = None,
         channel: Literal["chrome", "msedge", "chromium"] = "chromium",
         cookie_json_path: Optional[str] = None,
+        user_data_dir: Optional[str] = None,
     ):
         r"""
         Initialize the asynchronous browser core.
@@ -136,7 +137,11 @@ class AsyncBaseBrowser:
             cookie_json_path (Optional[str]): Path to a JSON file containing
                 authentication cookies and browser storage state. If provided
                 and the file exists, the browser will load this state to
-                maintain authenticated sessions without requiring manual login.
+                maintain authenticated sessions. This is primarily used when
+                `user_data_dir` is not set.
+            user_data_dir (Optional[str]): The directory to store user data
+                for persistent context. If None, a fresh browser instance
+                is used without saving data. (default: :obj:`None`)
 
         Returns:
             None
@@ -151,6 +156,7 @@ class AsyncBaseBrowser:
         self.playwright = async_playwright()
         self.page_history: list[Any] = []
         self.cookie_json_path = cookie_json_path
+        self.user_data_dir = user_data_dir
         self.playwright_server: Any = None
         self.playwright_started: bool = False
         self.browser: Any = None
@@ -163,6 +169,10 @@ class AsyncBaseBrowser:
         self.cache_dir = "tmp/" if cache_dir is None else cache_dir
         os.makedirs(self.cache_dir, exist_ok=True)
 
+        # Create user data directory only if specified
+        if self.user_data_dir:
+            os.makedirs(self.user_data_dir, exist_ok=True)
+
         # Load the page script
         abs_dir_path = os.path.dirname(os.path.abspath(__file__))
         page_script_path = os.path.join(abs_dir_path, "page_script.js")
@@ -183,23 +193,56 @@ class AsyncBaseBrowser:
             await self._ensure_browser_installed()
             self.playwright_server = await self.playwright.start()
             self.playwright_started = True
-        # Launch the browser asynchronously.
-        self.browser = await self.playwright_server.chromium.launch(
-            headless=self.headless, channel=self.channel
+
+        browser_launch_args = [
+            "--disable-blink-features=AutomationControlled",  # Basic stealth
+        ]
+
+        user_agent_string = (
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+            "AppleWebKit/537.36 (KHTML, like Gecko) "
+            "Chrome/91.0.4472.124 Safari/537.36"
         )
-        # Check if cookie file exists before using it to maintain
-        # authenticated sessions. This prevents errors when the cookie file
-        # doesn't exist
-        if self.cookie_json_path and os.path.exists(self.cookie_json_path):
-            self.context = await self.browser.new_context(
-                accept_downloads=True, storage_state=self.cookie_json_path
+
+        if self.user_data_dir:
+            self.context = await (
+                self.playwright_server.chromium.launch_persistent_context(
+                    user_data_dir=self.user_data_dir,
+                    headless=self.headless,
+                    channel=self.channel,
+                    accept_downloads=True,
+                    user_agent=user_agent_string,
+                    java_script_enabled=True,
+                    args=browser_launch_args,
+                )
             )
+            self.browser = None  # Not using a separate browser instance
+            if len(self.context.pages) > 0:  # Persistent context might
+                # reopen pages
+                self.page = self.context.pages[0]
+            else:
+                self.page = await self.context.new_page()
         else:
-            self.context = await self.browser.new_context(
-                accept_downloads=True,
+            # Launch a fresh browser instance
+            self.browser = await self.playwright_server.chromium.launch(
+                headless=self.headless,
+                channel=self.channel,
+                args=browser_launch_args,
             )
-        # Create a new page asynchronously.
-        self.page = await self.context.new_page()
+
+            new_context_kwargs: Dict[str, Any] = {
+                "accept_downloads": True,
+                "user_agent": user_agent_string,
+                "java_script_enabled": True,
+            }
+            if self.cookie_json_path and os.path.exists(self.cookie_json_path):
+                new_context_kwargs["storage_state"] = self.cookie_json_path
+
+            self.context = await self.browser.new_context(**new_context_kwargs)
+            self.page = await self.context.new_page()
+
+        assert self.context is not None
+        assert self.page is not None
 
     def init(self) -> Coroutine[Any, Any, None]:
         r"""Initialize the browser asynchronously."""
@@ -827,7 +870,14 @@ class AsyncBaseBrowser:
 
     async def async_close(self) -> None:
         r"""Asynchronously close the browser."""
-        await self.browser.close()
+        if self.context is not None:
+            await self.context.close()
+        if self.browser is not None:  # Only close browser if it was
+            # launched separately
+            await self.browser.close()
+        if self.playwright_server and self.playwright_started:
+            await self.playwright_server.stop()
+            self.playwright_started = False
 
     def close(self) -> Coroutine[Any, Any, None]:
         r"""Close the browser."""
@@ -943,6 +993,7 @@ class AsyncBrowserToolkit(BaseToolkit):
         planning_agent_model: Optional[BaseModelBackend] = None,
         output_language: str = "en",
         cookie_json_path: Optional[str] = None,
+        user_data_dir: Optional[str] = None,
     ):
         r"""Initialize the BrowserToolkit instance.
 
@@ -966,6 +1017,8 @@ class AsyncBrowserToolkit(BaseToolkit):
                 maintain authenticated sessions without requiring manual
                 login.
                 (default: :obj:`None`)
+            user_data_dir (Optional[str]): The directory to store user data
+                for persistent context. (default: :obj:`"user_data_dir/"`)
         """
         super().__init__()
         self.browser = AsyncBaseBrowser(
@@ -973,6 +1026,7 @@ class AsyncBrowserToolkit(BaseToolkit):
             cache_dir=cache_dir,
             channel=channel,
             cookie_json_path=cookie_json_path,
+            user_data_dir=user_data_dir,
         )
 
         self.history_window = history_window
@@ -991,7 +1045,7 @@ class AsyncBrowserToolkit(BaseToolkit):
         os.makedirs(self.browser.cache_dir, exist_ok=True)
 
     def _initialize_agent(self) -> Tuple["ChatAgent", "ChatAgent"]:
-        r"""Initialize the agent."""
+        r"""Initialize the planning and web agents."""
         from camel.agents.chat_agent import ChatAgent
 
         if self.web_agent_model is None:
@@ -1060,7 +1114,7 @@ Here is a plan about how to solve the task step-by-step which you must follow:
         )
         # Reset the history message of web_agent.
         self.web_agent.reset()
-        resp = self.web_agent.step(message)
+        resp = await self.web_agent.astep(message)
 
         resp_content = resp.msgs[0].content
 
@@ -1196,43 +1250,29 @@ Here is a plan about how to solve the task step-by-step which you must follow:
                 f"correct identifier.",
             )
 
-    def _get_final_answer(self, task_prompt: str) -> str:
-        r"""Get the final answer based on the task prompt and current browser
-        state. It is used when the agent thinks that the task can be completed
-        without any further action, and answer can be directly found in the
-        current viewport.
-        """
-
-        prompt = GET_FINAL_ANSWER_PROMPT_TEMPLATE.format(
-            history=self.history, task_prompt=task_prompt
-        )
-
-        message = BaseMessage.make_user_message(
-            role_name='user',
-            content=prompt,
+    async def _async_get_final_answer(self, task_prompt: str) -> str:
+        r"""Generate the final answer based on the task prompt."""
+        final_answer_prompt = GET_FINAL_ANSWER_PROMPT_TEMPLATE.format(
+            task_prompt=task_prompt, history=self.history
         )
+        response = await self.planning_agent.astep(final_answer_prompt)
+        if response.msgs is None or len(response.msgs) == 0:
+            raise RuntimeError("Got empty final answer from planning agent.")
+        return response.msgs[0].content
 
-        resp = self.web_agent.step(message)
-        return resp.msgs[0].content
-
-    def _task_planning(self, task_prompt: str, start_url: str) -> str:
-        r"""Plan the task based on the given task prompt."""
-
-        # Here are the available browser functions we can
-        # use: {AVAILABLE_ACTIONS_PROMPT}
-
+    async def _async_task_planning(
+        self, task_prompt: str, start_url: str
+    ) -> str:
+        r"""Generate a detailed plan for the given task."""
         planning_prompt = TASK_PLANNING_PROMPT_TEMPLATE.format(
             task_prompt=task_prompt, start_url=start_url
         )
+        response = await self.planning_agent.astep(planning_prompt)
+        if response.msgs is None or len(response.msgs) == 0:
+            raise RuntimeError("Got empty plan from planning agent.")
+        return response.msgs[0].content
 
-        message = BaseMessage.make_user_message(
-            role_name='user', content=planning_prompt
-        )
-
-        resp = self.planning_agent.step(message)
-        return resp.msgs[0].content
-
-    def _task_replanning(
+    async def _async_task_replanning(
         self, task_prompt: str, detailed_plan: str
     ) -> Tuple[bool, str]:
         r"""Replan the task based on the given task prompt.
@@ -1252,12 +1292,11 @@ Here is a plan about how to solve the task step-by-step which you must follow:
         replanning_prompt = TASK_REPLANNING_PROMPT_TEMPLATE.format(
             task_prompt=task_prompt,
             detailed_plan=detailed_plan,
-            history_window=self.history_window,
             history=self.history[-self.history_window :],
         )
         # Reset the history message of planning_agent.
         self.planning_agent.reset()
-        resp = self.planning_agent.step(replanning_prompt)
+        resp = await self.planning_agent.astep(replanning_prompt)
         resp_dict = _parse_json_output(resp.msgs[0].content, logger)
 
         if_need_replan = resp_dict.get("if_need_replan", False)
@@ -1287,7 +1326,7 @@ Here is a plan about how to solve the task step-by-step which you must follow:
 
         self._reset()
         task_completed = False
-        detailed_plan = self._task_planning(task_prompt, start_url)
+        detailed_plan = await self._async_task_planning(task_prompt, start_url)
         logger.debug(f"Detailed plan: {detailed_plan}")
 
         await self.browser.async_init()
@@ -1331,7 +1370,11 @@ Here is a plan about how to solve the task step-by-step which you must follow:
                 self.history.append(trajectory_info)
 
                 # replan the task if necessary
-                if_need_replan, replanned_schema = self._task_replanning(
+                (
+                    if_need_replan,
+                    replanned_schema,
+                    # ruff: noqa: E501
+                ) = await self._async_task_replanning(
                     task_prompt, detailed_plan
                 )
                 if if_need_replan:
@@ -1343,11 +1386,11 @@ Here is a plan about how to solve the task step-by-step which you must follow:
                 The task is not completed within the round limit. Please check 
                 the last round {self.history_window} information to see if 
                 there is any useful information:
-                <history>{self.history[-self.history_window :]}</history>
+                <history>{self.history[-self.history_window:]}</history>
             """
 
         else:
-            simulation_result = self._get_final_answer(task_prompt)
+            simulation_result = await self._async_get_final_answer(task_prompt)
 
         await self.browser.close()
         return simulation_result

camel/toolkits/browser_toolkit.py

@@ -125,6 +125,7 @@ class BaseBrowser:
         cache_dir: Optional[str] = None,
         channel: Literal["chrome", "msedge", "chromium"] = "chromium",
         cookie_json_path: Optional[str] = None,
+        user_data_dir: Optional[str] = None,
     ):
         r"""Initialize the WebBrowser instance.
 
@@ -137,8 +138,11 @@ class BaseBrowser:
             cookie_json_path (Optional[str]): Path to a JSON file containing
                 authentication cookies and browser storage state. If provided
                 and the file exists, the browser will load this state to
-                maintain
-                authenticated sessions without requiring manual login.
+                maintain authenticated sessions. This is primarily used when
+                `user_data_dir` is not set.
+            user_data_dir (Optional[str]): The directory to store user data
+                for persistent context. If None, a fresh browser instance
+                is used without saving data. (default: :obj:`None`)
 
         Returns:
             None
@@ -156,11 +160,16 @@ class BaseBrowser:
             str
         ] = []  # stores the history of visited pages
         self.cookie_json_path = cookie_json_path
+        self.user_data_dir = user_data_dir
 
         # Set the cache directory
         self.cache_dir = "tmp/" if cache_dir is None else cache_dir
         os.makedirs(self.cache_dir, exist_ok=True)
 
+        # Create user data directory only if specified
+        if self.user_data_dir:
+            os.makedirs(self.user_data_dir, exist_ok=True)
+
         # Load the page script
         abs_dir_path = os.path.dirname(os.path.abspath(__file__))
         page_script_path = os.path.join(abs_dir_path, "page_script.js")
@@ -183,27 +192,56 @@ class BaseBrowser:
 
     def init(self) -> None:
         r"""Initialize the browser."""
-        # Launch the browser, if headless is False, the browser will display
         assert self.playwright is not None
-        self.browser = self.playwright.chromium.launch(
-            headless=self.headless, channel=self.channel
+
+        browser_launch_args = [
+            "--disable-blink-features=AutomationControlled",  # Basic stealth
+        ]
+
+        user_agent_string = (
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+            "AppleWebKit/537.36 (KHTML, like Gecko) "
+            "Chrome/91.0.4472.124 Safari/537.36"
         )
 
-        # Check if cookie file exists before using it to maintain
-        # authenticated sessions. This prevents errors when the cookie file
-        # doesn't exist
-        assert self.browser is not None
-        if self.cookie_json_path and os.path.exists(self.cookie_json_path):
-            self.context = self.browser.new_context(
-                accept_downloads=True, storage_state=self.cookie_json_path
+        if self.user_data_dir:
+            self.context = self.playwright.chromium.launch_persistent_context(
+                user_data_dir=self.user_data_dir,
+                headless=self.headless,
+                channel=self.channel,
+                accept_downloads=True,
+                user_agent=user_agent_string,
+                java_script_enabled=True,
+                args=browser_launch_args,
             )
+            self.browser = None  # Not using a separate browser instance
+            if (
+                len(self.context.pages) > 0
+            ):  # Persistent context might reopen pages
+                self.page = self.context.pages[0]
+            else:
+                self.page = self.context.new_page()
         else:
-            self.context = self.browser.new_context(
-                accept_downloads=True,
+            # Launch a fresh browser instance
+            self.browser = self.playwright.chromium.launch(
+                headless=self.headless,
+                channel=self.channel,
+                args=browser_launch_args,
             )
-        # Create a new page
+
+            new_context_kwargs: Dict[str, Any] = {
+                "accept_downloads": True,
+                "user_agent": user_agent_string,
+                "java_script_enabled": True,
+            }
+            if self.cookie_json_path and os.path.exists(self.cookie_json_path):
+                new_context_kwargs["storage_state"] = self.cookie_json_path
+
+            self.context = self.browser.new_context(**new_context_kwargs)
+            self.page = self.context.new_page()
+
         assert self.context is not None
-        self.page = self.context.new_page()
+        assert self.page is not None
 
     def clean_cache(self) -> None:
         r"""Delete the cache directory and its contents."""
@@ -690,8 +728,12 @@ class BaseBrowser:
         self._wait_for_load()
 
     def close(self):
-        assert self.browser is not None
-        self.browser.close()
+        if self.context is not None:
+            self.context.close()
+        if (
+            self.browser is not None
+        ):  # Only close browser if it was launched separately
+            self.browser.close()
         if self.playwright:
             self.playwright.stop()  # Stop playwright instance
 
@@ -781,6 +823,7 @@ class BrowserToolkit(BaseToolkit):
         planning_agent_model: Optional[BaseModelBackend] = None,
         output_language: str = "en",
         cookie_json_path: Optional[str] = None,
+        user_data_dir: Optional[str] = None,
     ):
         r"""Initialize the BrowserToolkit instance.
 
@@ -804,6 +847,9 @@ class BrowserToolkit(BaseToolkit):
                 maintain
                 authenticated sessions without requiring manual login.
                 (default: :obj:`None`)
+            user_data_dir (Optional[str]): The directory to store user data
+                for persistent context. If None, a fresh browser instance
+                is used without saving data. (default: :obj:`None`)
         """
         super().__init__()  # Call to super().__init__() added
         self.browser = BaseBrowser(
@@ -811,6 +857,7 @@ class BrowserToolkit(BaseToolkit):
             cache_dir=cache_dir,
             channel=channel,
             cookie_json_path=cookie_json_path,
+            user_data_dir=user_data_dir,
         )
         self.browser.web_agent_model = web_agent_model  # Pass model to
         # BaseBrowser instance

camel/toolkits/function_tool.py

@@ -547,7 +547,7 @@ class FunctionTool:
         """
         self.openai_tool_schema["function"]["description"] = description
 
-    def get_paramter_description(self, param_name: str) -> str:
+    def get_parameter_description(self, param_name: str) -> str:
         r"""Gets the description of a specific parameter from the function
         schema.
 
@@ -563,7 +563,7 @@ class FunctionTool:
             param_name
         ]["description"]
 
-    def set_paramter_description(
+    def set_parameter_description(
         self,
         param_name: str,
         description: str,

camel/toolkits/playwright_mcp_toolkit.py

@@ -27,17 +27,29 @@ class PlaywrightMCPToolkit(BaseToolkit):
     Attributes:
         timeout (Optional[float]): Connection timeout in seconds.
             (default: :obj:`None`)
+        additional_args (Optional[List[str]]): Additional command-line
+            arguments to pass to the Playwright MCP server. For example,
+            `["--cdp-endpoint=http://localhost:9222"]`.
+            (default: :obj:`None`)
 
     Note:
         Currently only supports asynchronous operation mode.
     """
 
-    def __init__(self, timeout: Optional[float] = None) -> None:
-        r"""Initializes the PlaywrightMCPToolkit with the specified timeout.
+    def __init__(
+        self,
+        timeout: Optional[float] = None,
+        additional_args: Optional[List[str]] = None,
+    ) -> None:
+        r"""Initializes the PlaywrightMCPToolkit.
 
         Args:
             timeout (Optional[float]): Connection timeout in seconds.
                 (default: :obj:`None`)
+            additional_args (Optional[List[str]]): Additional command-line
+                arguments to pass to the Playwright MCP server. For example,
+                `["--cdp-endpoint=http://localhost:9222"]`.
+                (default: :obj:`None`)
         """
         super().__init__(timeout=timeout)
 
@@ -46,7 +58,8 @@ class PlaywrightMCPToolkit(BaseToolkit):
                 "mcpServers": {
                     "playwright": {
                         "command": "npx",
-                        "args": ["@playwright/mcp@latest"],
+                        "args": ["@playwright/mcp@latest"]
+                        + (additional_args or []),
                     }
                 }
             }