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

camel/tasks/task.py

@@ -19,15 +19,66 @@ from typing import Any, Callable, Dict, List, Literal, Optional, Union
 from pydantic import BaseModel
 
 from camel.agents import ChatAgent
+from camel.logger import get_logger
 from camel.messages import BaseMessage
 from camel.prompts import TextPrompt
 
+# Note: validate_task_content moved here to avoid circular imports
 from .task_prompt import (
     TASK_COMPOSE_PROMPT,
     TASK_DECOMPOSE_PROMPT,
     TASK_EVOLVE_PROMPT,
 )
 
+logger = get_logger(__name__)
+
+
+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
+
 
 def parse_response(
     response: str, task_id: Optional[str] = None
@@ -49,7 +100,16 @@ def parse_response(
     if task_id is None:
         task_id = "0"
     for i, content in enumerate(tasks_content):
-        tasks.append(Task(content=content.strip(), id=f"{task_id}.{i}"))
+        stripped_content = content.strip()
+        # validate subtask content before creating the task
+        if validate_task_content(stripped_content, f"{task_id}.{i}"):
+            tasks.append(Task(content=stripped_content, id=f"{task_id}.{i}"))
+        else:
+            logger.warning(
+                f"Skipping invalid subtask {task_id}.{i} "
+                f"during decomposition: "
+                f"Content '{stripped_content[:50]}...' failed validation"
+            )
     return tasks
 
 
@@ -106,6 +166,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

@@ -190,7 +190,9 @@ def sanitize_and_enforce_required(parameters_dict):
     r"""Cleans and updates the function schema to conform with OpenAI's
     requirements:
     - Removes invalid 'default' fields from the parameters schema.
-    - Ensures all fields or function parameters are marked as required.
+    - Ensures all fields are marked as required or have null type for optional
+    fields.
+    - Recursively adds additionalProperties: false to all nested objects.
 
     Args:
         parameters_dict (dict): The dictionary representing the function
@@ -198,8 +200,38 @@ def sanitize_and_enforce_required(parameters_dict):
 
     Returns:
         dict: The updated dictionary with invalid defaults removed and all
-            fields set as required.
+            fields properly configured for strict mode.
     """
+
+    def _add_additional_properties_false(obj):
+        r"""Recursively add additionalProperties: false to all objects."""
+        if isinstance(obj, dict):
+            if (
+                obj.get("type") == "object"
+                and "additionalProperties" not in obj
+            ):
+                obj["additionalProperties"] = False
+
+            # Process nested structures
+            for key, value in obj.items():
+                if key == "properties" and isinstance(value, dict):
+                    for prop_value in value.values():
+                        _add_additional_properties_false(prop_value)
+                elif key in [
+                    "items",
+                    "allOf",
+                    "oneOf",
+                    "anyOf",
+                ] and isinstance(value, (dict, list)):
+                    if isinstance(value, dict):
+                        _add_additional_properties_false(value)
+                    elif isinstance(value, list):
+                        for item in value:
+                            _add_additional_properties_false(item)
+                elif key == "$defs" and isinstance(value, dict):
+                    for def_value in value.values():
+                        _add_additional_properties_false(def_value)
+
     # Check if 'function' and 'parameters' exist
     if (
         'function' in parameters_dict
@@ -209,12 +241,52 @@ def sanitize_and_enforce_required(parameters_dict):
         parameters = parameters_dict['function']['parameters']
         properties = parameters.get('properties', {})
 
-        # Remove 'default' key from each property
-        for field in properties.values():
-            field.pop('default', None)
+        # Track which fields should be required vs optional
+        required_fields = []
+
+        # Process each property
+        for field_name, field_schema in properties.items():
+            # Check if this field had a default value (making it optional)
+            had_default = 'default' in field_schema
+
+            # Remove 'default' key from field schema as required by OpenAI
+            field_schema.pop('default', None)
+
+            if had_default:
+                # This field is optional - add null to its type
+                current_type = field_schema.get('type')
+                has_ref = '$ref' in field_schema
+
+                if has_ref:
+                    # Fields with $ref shouldn't have additional type field
+                    # The $ref itself defines the type structure
+                    pass
+                elif current_type:
+                    if isinstance(current_type, str):
+                        # Single type - convert to array with null
+                        field_schema['type'] = [current_type, 'null']
+                    elif (
+                        isinstance(current_type, list)
+                        and 'null' not in current_type
+                    ):
+                        # Array of types - add null if not present
+                        field_schema['type'] = [*current_type, 'null']
+                else:
+                    # No type specified, add null type
+                    field_schema['type'] = ['null']
+
+                # Optional fields are still marked as required in strict mode
+                # but with null type to indicate they can be omitted
+                required_fields.append(field_name)
+            else:
+                # This field is required
+                required_fields.append(field_name)
+
+        # Set all fields as required (strict mode requirement)
+        parameters['required'] = required_fields
 
-        # Mark all keys in 'properties' as required
-        parameters['required'] = list(properties.keys())
+        # Recursively add additionalProperties: false to all objects
+        _add_additional_properties_false(parameters)
 
     return parameters_dict
 
@@ -547,7 +619,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 +635,7 @@ class FunctionTool:
             param_name
         ]["description"]
 
-    def set_paramter_description(
+    def set_parameter_description(
         self,
         param_name: str,
         description: str,