camel-ai 0.2.69a3__py3-none-any.whl → 0.2.69a6__py3-none-any.whl

camel/__init__.py

@@ -14,7 +14,7 @@
 
 from camel.logger import disable_logging, enable_logging, set_log_level
 
-__version__ = '0.2.69a3'
+__version__ = '0.2.69a6'
 
 __all__ = [
     '__version__',

camel/agents/chat_agent.py

@@ -1904,36 +1904,12 @@ class ChatAgent(BaseAgent):
             ChatAgent: A new instance of :obj:`ChatAgent` with the same
                 configuration.
         """
-        import copy
-
         # Create a new instance with the same configuration
         # If with_memory is True, set system_message to None
         # If with_memory is False, use the original system message
         # To avoid duplicated system memory.
         system_message = None if with_memory else self._original_system_message
 
-        # Create deep copies of tools to avoid shared state
-        cloned_tools: List[Union[FunctionTool, Callable]] = []
-        for tool in self._internal_tools.values():
-            # Create a new FunctionTool instance to avoid sharing state
-            cloned_tool = copy.deepcopy(tool)
-            cloned_tools.append(cloned_tool)
-
-        # Create deep copies of external tool schemas
-        cloned_external_tools: List[
-            Union[FunctionTool, Callable, Dict[str, Any]]
-        ] = []
-        for schema in self._external_tool_schemas.values():
-            cloned_schema = copy.deepcopy(schema)
-            cloned_external_tools.append(cloned_schema)
-
-        # Create deep copies of response terminators to avoid shared state
-        cloned_terminators: List[ResponseTerminator] = []
-        if self.response_terminators:
-            for terminator in self.response_terminators:
-                cloned_terminator = copy.deepcopy(terminator)
-                cloned_terminators.append(cloned_terminator)
-
         new_agent = ChatAgent(
             system_message=system_message,
             model=self.model_backend.models,  # Pass the existing model_backend
@@ -1943,9 +1919,11 @@ class ChatAgent(BaseAgent):
                 self.memory.get_context_creator(), "token_limit", None
             ),
             output_language=self._output_language,
-            tools=cloned_tools,
-            external_tools=cloned_external_tools,
-            response_terminators=cloned_terminators,
+            tools=[tool.func for tool in self._internal_tools.values()],
+            external_tools=[
+                schema for schema in self._external_tool_schemas.values()
+            ],
+            response_terminators=self.response_terminators,
             scheduling_strategy=self.model_backend.scheduling_strategy.__name__,
             max_iteration=self.max_iteration,
             stop_event=self.stop_event,

camel/interpreters/internal_python_interpreter.py

@@ -79,6 +79,9 @@ class InternalPythonInterpreter(BaseInterpreter):
             (default: :obj:`False`)
         raise_error (bool, optional): Raise error if the interpreter fails.
             (default: :obj:`False`)
+        allow_builtins (bool, optional): If `True`, safe built-in functions
+            like print, len, str, etc. are added to the action space.
+            (default: :obj:`True`)
     """
 
     _CODE_TYPES: ClassVar[List[str]] = ["python", "py", "python3", "python2"]
@@ -89,16 +92,62 @@ class InternalPythonInterpreter(BaseInterpreter):
         import_white_list: Optional[List[str]] = None,
         unsafe_mode: bool = False,
         raise_error: bool = False,
+        allow_builtins: bool = True,
     ) -> None:
         self.action_space = action_space or dict()
-        # Add print to action space
-        self.action_space['print'] = print
         self.state = self.action_space.copy()
         self.fuzz_state: Dict[str, Any] = dict()
         self.import_white_list = import_white_list or list()
         self.raise_error = raise_error
         self.unsafe_mode = unsafe_mode
 
+        # Add safe built-in functions if allowed
+        if allow_builtins:
+            self._add_safe_builtins()
+
+    def _add_safe_builtins(self):
+        r"""Add safe built-in functions to the action space."""
+        safe_builtins = {
+            'print': print,
+            'len': len,
+            'str': str,
+            'int': int,
+            'float': float,
+            'bool': bool,
+            'list': list,
+            'dict': dict,
+            'tuple': tuple,
+            'set': set,
+            'abs': abs,
+            'min': min,
+            'max': max,
+            'sum': sum,
+            'sorted': sorted,
+            'reversed': reversed,
+            'enumerate': enumerate,
+            'zip': zip,
+            'range': range,
+            'round': round,
+            'type': type,
+            'isinstance': isinstance,
+            'hasattr': hasattr,
+            'getattr': getattr,
+            'setattr': setattr,
+            'dir': dir,
+            'help': help,
+            'map': map,
+            'filter': filter,
+            'any': any,
+            'all': all,
+            'ord': ord,
+            'chr': chr,
+            'bin': bin,
+            'oct': oct,
+            'hex': hex,
+        }
+        self.action_space.update(safe_builtins)
+        self.state.update(safe_builtins)
+
     def run(self, code: str, code_type: str = "python") -> str:
         r"""Executes the given code with specified code type in the
         interpreter.

camel/models/base_model.py

@@ -12,6 +12,7 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import abc
+import os
 import re
 from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Optional, Type, Union
@@ -94,6 +95,12 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
         self._token_counter = token_counter
         self._timeout = timeout
         self._max_retries = max_retries
+        # Initialize logging configuration
+        self._log_enabled = (
+            os.environ.get("CAMEL_MODEL_LOG_ENABLED", "False").lower()
+            == "true"
+        )
+        self._log_dir = os.environ.get("CAMEL_LOG_DIR", "camel_logs")
         self.check_model_config()
 
     @property
@@ -232,6 +239,68 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
 
         return formatted_messages
 
+    def _log_request(self, messages: List[OpenAIMessage]) -> Optional[str]:
+        r"""Log the request messages to a JSON file if logging is enabled.
+
+        Args:
+            messages (List[OpenAIMessage]): The messages to log.
+
+        Returns:
+            Optional[str]: The path to the log file if logging is enabled,
+                None otherwise.
+        """
+        if not self._log_enabled:
+            return None
+
+        import json
+        from datetime import datetime
+
+        os.makedirs(self._log_dir, exist_ok=True)
+
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S_%f')
+        log_file_path = os.path.join(self._log_dir, f"conv_{timestamp}.json")
+
+        log_entry = {
+            "request_timestamp": datetime.now().isoformat(),
+            "model": str(self.model_type),
+            "request": {"messages": messages},
+        }
+
+        with open(log_file_path, "w") as f:
+            json.dump(log_entry, f, indent=4)
+
+        return log_file_path
+
+    def _log_response(self, log_path: str, response: Any) -> None:
+        r"""Log the response to the existing log file.
+
+        Args:
+            log_path (str): The path to the log file.
+            response (Any): The response to log.
+        """
+        if not self._log_enabled or not log_path:
+            return
+
+        import json
+        from datetime import datetime
+
+        with open(log_path, "r+") as f:
+            log_data = json.load(f)
+
+            log_data["response_timestamp"] = datetime.now().isoformat()
+            if isinstance(response, BaseModel):
+                log_data["response"] = response.model_dump()
+            else:
+                try:
+                    json.dumps(response)
+                    log_data["response"] = response
+                except TypeError:
+                    log_data["response"] = str(response)
+
+            f.seek(0)
+            json.dump(log_data, f, indent=4)
+            f.truncate()
+
     @abstractmethod
     def _run(
         self,
@@ -273,13 +342,23 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
                 `ChatCompletion` in the non-stream mode, or
                 `Stream[ChatCompletionChunk]` in the stream mode.
         """
+        # Log the request if logging is enabled
+        log_path = self._log_request(messages)
+
         # None -> use default tools
         if tools is None:
             tools = self.model_config_dict.get("tools", None)
         # Empty -> use no tools
         elif not tools:
             tools = None
-        return self._run(messages, response_format, tools)
+
+        result = self._run(messages, response_format, tools)
+
+        # Log the response if logging is enabled
+        if log_path:
+            self._log_response(log_path, result)
+
+        return result
 
     async def arun(
         self,
@@ -304,11 +383,21 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
                 `ChatCompletion` in the non-stream mode, or
                 `AsyncStream[ChatCompletionChunk]` in the stream mode.
         """
+        # Log the request if logging is enabled
+        log_path = self._log_request(messages)
+
         if tools is None:
             tools = self.model_config_dict.get("tools", None)
         elif not tools:
             tools = None
-        return await self._arun(messages, response_format, tools)
+
+        result = await self._arun(messages, response_format, tools)
+
+        # Log the response if logging is enabled
+        if log_path:
+            self._log_response(log_path, result)
+
+        return result
 
     @abstractmethod
     def check_model_config(self):

camel/societies/workforce/single_agent_worker.py

@@ -284,6 +284,13 @@ class SingleAgentWorker(Worker):
             response = await worker_agent.astep(
                 prompt, response_format=TaskResult
             )
+
+            # Get token usage from the response
+            usage_info = response.info.get("usage") or response.info.get(
+                "token_usage"
+            )
+            total_tokens = usage_info.get("total_tokens", 0)
+
         except Exception as e:
             print(
                 f"{Fore.RED}Error processing task {task.id}: "
@@ -294,13 +301,6 @@ class SingleAgentWorker(Worker):
             # Return agent to pool or let it be garbage collected
             await self._return_worker_agent(worker_agent)
 
-        # Get actual token usage from the agent that processed this task
-        try:
-            _, total_token_count = worker_agent.memory.get_context()
-        except Exception:
-            # Fallback if memory context unavailable
-            total_token_count = 0
-
         # Populate additional_info with worker attempt details
         if task.additional_info is None:
             task.additional_info = {}
@@ -321,7 +321,7 @@ class SingleAgentWorker(Worker):
             f"to process task {task.content}",
             "response_content": response.msg.content,
             "tool_calls": response.info.get("tool_calls"),
-            "total_token_count": total_token_count,
+            "total_tokens": total_tokens,
         }
 
         # Store the worker attempt in additional_info
@@ -330,9 +330,7 @@ class SingleAgentWorker(Worker):
         task.additional_info["worker_attempts"].append(worker_attempt_details)
 
         # Store the actual token usage for this specific task
-        task.additional_info["token_usage"] = {
-            "total_tokens": total_token_count
-        }
+        task.additional_info["token_usage"] = {"total_tokens": total_tokens}
 
         print(f"======\n{Fore.GREEN}Reply from {self}:{Fore.RESET}")
 

camel/toolkits/__init__.py

@@ -78,6 +78,9 @@ from .playwright_mcp_toolkit import PlaywrightMCPToolkit
 from .wolfram_alpha_toolkit import WolframAlphaToolkit
 from .task_planning_toolkit import TaskPlanningToolkit
 from .non_visual_browser_toolkit import BrowserNonVisualToolkit
+from .edgeone_pages_mcp_toolkit import EdgeOnePagesMCPToolkit
+from .craw4ai_toolkit import Crawl4AIToolkit
+from .markitdown_toolkit import MarkItDownToolkit
 
 
 __all__ = [
@@ -144,4 +147,7 @@ __all__ = [
     'BohriumToolkit',
     'TaskPlanningToolkit',
     'BrowserNonVisualToolkit',
+    'EdgeOnePagesMCPToolkit',
+    'Crawl4AIToolkit',
+    'MarkItDownToolkit',
 ]

camel/toolkits/craw4ai_toolkit.py

@@ -0,0 +1,73 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+from typing import List, Optional
+
+from camel.logger import get_logger
+from camel.toolkits.base import BaseToolkit
+from camel.toolkits.function_tool import FunctionTool
+from camel.utils import MCPServer
+
+logger = get_logger(__name__)
+
+
+@MCPServer()
+class Crawl4AIToolkit(BaseToolkit):
+    r"""A class representing a toolkit for Crawl4AI."""
+
+    def __init__(
+        self,
+        timeout: Optional[float] = None,
+    ):
+        super().__init__(timeout=timeout)
+
+    async def scrape(self, url: str) -> str:
+        r"""Scrapes a webpage and returns its content.
+
+        This function is designed to fetch the content of a given URL and
+        return it as a single string. It's particularly useful for extracting
+        text from web pages for further processing. The function
+        will try to get the most meaningful content from the page.
+
+        Args:
+            url (str): The URL of the webpage to scrape.
+
+        Returns:
+            str: The scraped content of the webpage as a string. If the
+                scraping fails, it will return an error message.
+        """
+        from crawl4ai import AsyncWebCrawler, CrawlerRunConfig
+
+        try:
+            async with AsyncWebCrawler() as client:
+                config = CrawlerRunConfig(
+                    only_text=True,
+                )
+                content = await client.arun(url, crawler_config=config)
+                return str(content.markdown) if content.markdown else ""
+        except Exception as e:
+            logger.error(f"Error scraping {url}: {e}")
+            return f"Error scraping {url}: {e}"
+
+    def get_tools(self) -> List[FunctionTool]:
+        r"""Returns a list of FunctionTool objects representing the
+        functions in the toolkit.
+
+        Returns:
+            List[FunctionTool]: A list of FunctionTool objects
+                representing the functions in the toolkit.
+        """
+        return [
+            FunctionTool(self.scrape),
+        ]

camel/toolkits/edgeone_pages_mcp_toolkit.py

@@ -0,0 +1,69 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+from typing import List, Optional
+
+from camel.toolkits import BaseToolkit, FunctionTool
+
+from .mcp_toolkit import MCPToolkit
+
+
+class EdgeOnePagesMCPToolkit(BaseToolkit):
+    r"""EdgeOnePagesMCPToolkit provides an interface for interacting with
+    EdgeOne pages using the EdgeOne Pages MCP server.
+
+    Attributes:
+        timeout (Optional[float]): Connection timeout in seconds.
+            (default: :obj:`None`)
+    """
+
+    def __init__(
+        self,
+        timeout: Optional[float] = None,
+    ) -> None:
+        r"""Initializes the EdgeOnePagesMCPToolkit.
+
+        Args:
+            timeout (Optional[float]): Connection timeout in seconds.
+                (default: :obj:`None`)
+        """
+        super().__init__(timeout=timeout)
+
+        self._mcp_toolkit = MCPToolkit(
+            config_dict={
+                "mcpServers": {
+                    "edgeone-pages-mcp-server": {
+                        "command": "npx",
+                        "args": ["edgeone-pages-mcp"],
+                    }
+                }
+            },
+            timeout=timeout,
+        )
+
+    async def connect(self):
+        r"""Explicitly connect to the EdgeOne Pages MCP server."""
+        await self._mcp_toolkit.connect()
+
+    async def disconnect(self):
+        r"""Explicitly disconnect from the EdgeOne Pages MCP server."""
+        await self._mcp_toolkit.disconnect()
+
+    def get_tools(self) -> List[FunctionTool]:
+        r"""Returns a list of tools provided by the EdgeOnePagesMCPToolkit.
+
+        Returns:
+            List[FunctionTool]: List of available tools.
+        """
+        return self._mcp_toolkit.get_tools()

camel/toolkits/markitdown_toolkit.py

@@ -0,0 +1,78 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+from typing import Dict, List, Optional
+
+from camel.loaders.markitdown import MarkItDownLoader
+from camel.logger import get_logger
+from camel.toolkits.base import BaseToolkit
+from camel.toolkits.function_tool import FunctionTool
+from camel.utils import MCPServer
+
+logger = get_logger(__name__)
+
+
+@MCPServer()
+class MarkItDownToolkit(BaseToolkit):
+    r"""A class representing a toolkit for MarkItDown."""
+
+    def __init__(
+        self,
+        timeout: Optional[float] = None,
+    ):
+        super().__init__(timeout=timeout)
+
+    def load_files(self, file_paths: List[str]) -> Dict[str, str]:
+        r"""Scrapes content from a list of files and converts it to Markdown.
+
+        This function takes a list of local file paths, attempts to convert
+        each file into Markdown format, and returns the converted content.
+        The conversion is performed in parallel for efficiency.
+
+        Supported file formats include:
+        - PDF (.pdf)
+        - Microsoft Office: Word (.doc, .docx), Excel (.xls, .xlsx),
+          PowerPoint (.ppt, .pptx)
+        - EPUB (.epub)
+        - HTML (.html, .htm)
+        - Images (.jpg, .jpeg, .png) for OCR
+        - Audio (.mp3, .wav) for transcription
+        - Text-based formats (.csv, .json, .xml, .txt)
+        - ZIP archives (.zip)
+
+        Args:
+            file_paths (List[str]): A list of local file paths to be
+                converted.
+
+        Returns:
+            Dict[str, str]: A dictionary where keys are the input file paths
+                and values are the corresponding content in Markdown format.
+                If conversion of a file fails, the value will contain an
+                error message.
+        """
+        return MarkItDownLoader().convert_files(
+            file_paths=file_paths, parallel=True
+        )
+
+    def get_tools(self) -> List[FunctionTool]:
+        r"""Returns a list of FunctionTool objects representing the
+        functions in the toolkit.
+
+        Returns:
+            List[FunctionTool]: A list of FunctionTool objects
+                representing the functions in the toolkit.
+        """
+        return [
+            FunctionTool(self.load_files),
+        ]

camel/toolkits/non_visual_browser_toolkit/browser_non_visual_toolkit.py

@@ -115,16 +115,19 @@ class BrowserNonVisualToolkit(BaseToolkit):
     async def open_browser(
         self, start_url: Optional[str] = None
     ) -> Dict[str, str]:
-        r"""Launch a Playwright browser session.
+        r"""Launches a new browser session. This should be the first step.
 
         Args:
-            start_url (Optional[str]): Optional URL to navigate to immediately
-                after the browser launches. If not provided, the browser will
-                not navigate to any URL. (default: :obj:`None`)
+            start_url (Optional[str]): The URL to navigate to after the browser
+                launches. If not provided, the browser will open with a blank
+                page. (default: :obj:`None`)
 
         Returns:
-            Dict[str, str]: Keys: ``result`` for action outcome,
-                ``snapshot`` for full DOM snapshot.
+            Dict[str, str]: A dictionary containing the result of the action
+                and a snapshot of the page. The keys are "result" and
+                "snapshot". The "snapshot" is a YAML-like representation of
+                the page's DOM structure, including element references
+                (e.g., "e3") that can be used in other tool calls.
         """
         await self._session.ensure_browser()
         if start_url:
@@ -136,10 +139,12 @@ class BrowserNonVisualToolkit(BaseToolkit):
         return {"result": "Browser session started.", "snapshot": snapshot}
 
     async def close_browser(self) -> str:
-        r"""Terminate the current browser session and free all resources.
+        r"""Closes the current browser session, freeing up all associated
+        resources. This should be called when the browsing task is complete.
 
         Returns:
-            str: Confirmation message.
+            str: A confirmation message indicating the session has been
+                closed.
         """
         # Close agent if it exists
         if self._agent is not None:
@@ -154,14 +159,17 @@ class BrowserNonVisualToolkit(BaseToolkit):
         return "Browser session closed."
 
     async def visit_page(self, url: str) -> Dict[str, str]:
-        r"""Navigate the current page to the specified URL.
+        r"""Navigates the current browser page to a new URL.
 
         Args:
-            url (str): The destination URL.
+            url (str): The URL to navigate to. Must be a fully qualified URL
+                (e.g., "https://www.google.com").
 
         Returns:
-            Dict[str, str]: Keys: ``result`` for action outcome,
-                ``snapshot`` for full DOM snapshot.
+            Dict[str, str]: A dictionary containing the navigation result and a
+                snapshot of the new page. The keys are "result" and
+                "snapshot". The "snapshot" provides a fresh view of the
+                page's DOM structure.
         """
         if not url or not isinstance(url, str):
             raise ValueError("visit_page(): 'url' must be a non-empty string")
@@ -192,14 +200,16 @@ class BrowserNonVisualToolkit(BaseToolkit):
         )
 
     async def click(self, *, ref: str) -> Dict[str, str]:
-        r"""Click an element identified by ``ref``
+        r"""Performs a click action on a specified element on the current page.
 
         Args:
-            ref (str): Element reference ID extracted from snapshot
-                (e.g.``"e3"``).
+            ref (str): The reference ID of the element to click. This ID is
+                obtained from the page snapshot (e.g., "e12").
 
         Returns:
-            Dict[str, str]: Result message from ``ActionExecutor``.
+            Dict[str, str]: A dictionary containing the result of the action.
+                If the click causes a change in the page's structure, a
+                "snapshot" key will be included with a diff of the changes.
         """
         self._validate_ref(ref, "click")
 
@@ -207,15 +217,16 @@ class BrowserNonVisualToolkit(BaseToolkit):
         return await self._exec_with_snapshot(action)
 
     async def type(self, *, ref: str, text: str) -> Dict[str, str]:
-        r"""Type text into an input or textarea element.
+        r"""Types text into an input field or textarea on the current page.
 
         Args:
-            ref (str): Element reference ID extracted from snapshot.
-                (e.g.``"e3"``).
-            text (str): The text to enter.
+            ref (str): The reference ID of the input element. This ID is
+                obtained from the page snapshot (e.g., "e25").
+            text (str): The text to be typed into the element.
 
         Returns:
-            Dict[str, str]: Execution result message.
+            Dict[str, str]: A dictionary containing the result of the action.
+                The key is "result".
         """
         self._validate_ref(ref, "type")
 
@@ -223,14 +234,17 @@ class BrowserNonVisualToolkit(BaseToolkit):
         return await self._exec_with_snapshot(action)
 
     async def select(self, *, ref: str, value: str) -> Dict[str, str]:
-        r"""Select an option in a ``<select>`` element.
+        r"""Selects an option from a dropdown (<select>) element on the page.
 
         Args:
-            ref (str): Element reference ID.
-            value (str): The value / option to select.
+            ref (str): The reference ID of the <select> element. This ID is
+                obtained from the page snapshot.
+            value (str): The value of the option to be selected. This should
+                match the 'value' attribute of an <option> tag.
 
         Returns:
-            Dict[str, str]: Execution result message.
+            Dict[str, str]: A dictionary containing the result of the action.
+                The key is "result".
         """
         self._validate_ref(ref, "select")
 
@@ -238,15 +252,16 @@ class BrowserNonVisualToolkit(BaseToolkit):
         return await self._exec_with_snapshot(action)
 
     async def scroll(self, *, direction: str, amount: int) -> Dict[str, str]:
-        r"""Scroll the page.
+        r"""Scrolls the current page up or down by a specified amount.
 
         Args:
-            direction (str): Scroll direction, should be ``"down"`` or
-                ``"up"``.
-            amount (int): Pixel distance to scroll.
+            direction (str): The direction to scroll. Must be either "up" or
+                "down".
+            amount (int): The number of pixels to scroll.
 
         Returns:
-            Dict[str, str]: Execution result message.
+            Dict[str, str]: A dictionary containing the result of the action.
+                The key is "result".
         """
         if direction not in ("up", "down"):
             logger.error("scroll(): 'direction' must be 'up' or 'down'")
@@ -258,53 +273,72 @@ class BrowserNonVisualToolkit(BaseToolkit):
         return await self._exec_with_snapshot(action)
 
     async def enter(self, *, ref: str) -> Dict[str, str]:
-        r"""Press the Enter key.
+        r"""Simulates pressing the Enter key on a specific element.
+        This is often used to submit forms.
 
         Args:
-            ref (str): Element reference ID to focus before pressing.
+            ref (str): The reference ID of the element to focus before
+                pressing Enter. This ID is obtained from the page snapshot.
 
         Returns:
-            Dict[str, str]: Execution result message.
+            Dict[str, str]: A dictionary containing the result of the action.
+                If pressing Enter causes a page navigation or DOM change, a
+                "snapshot" key will be included with a diff of the changes.
         """
         self._validate_ref(ref, "enter")
 
         action: Dict[str, Any] = {"type": "enter", "ref": ref}
         return await self._exec_with_snapshot(action)
 
-    async def wait_user(self, *, seconds: float = 1.0) -> Dict[str, str]:
-        r"""Pause execution for a given amount of *real* time and then
-        return a *full* page snapshot.
-
-        This is a convenience wrapper around the existing wait action for
-        scenarios where you encounter a CAPTCHA or need to pause for manual
-        user input, and want to retrieve the complete DOM snapshot afterward.
+    async def wait_user(
+        self,
+        timeout_sec: Optional[float] = None,
+    ) -> Dict[str, str]:
+        r"""Pauses the agent's execution and waits for human intervention.
+        This is useful for tasks that require manual steps, like solving a
+        CAPTCHA. The agent will print a message and wait for the user to
+        press the Enter key in the console.
 
         Args:
-            seconds (float): How long to sleep, expressed in seconds. Must
-                be a positive number. (default: :obj:`1.0`)
+            timeout_sec (Optional[float]): The maximum time in seconds to wait
+                for the user. If `None`, it will wait indefinitely. Defaults
+                to `None`. (default: :obj:`None`)
 
         Returns:
-            Dict[str, str]: Keys ``result`` and ``snapshot``.
+            Dict[str, str]: A dictionary containing a result message and a
+                full snapshot of the current page after the user has acted.
+                The keys are "result" and "snapshot".
         """
-        if seconds is None or seconds <= 0:
-            logger.error("wait_time(): 'seconds' must be a positive number")
-            return {
-                "result": "wait_time(): 'seconds' must be a positive number"
-            }
 
-        # Reuse underlying ActionExecutor's ``wait`` implementation (expects
-        # ms)
-        timeout_ms = int(seconds * 1000)
-        action: Dict[str, Any] = {"type": "wait", "timeout": timeout_ms}
+        import asyncio
+
+        prompt = (
+            "🕑 Agent is waiting for human input. "
+            "Complete the required action in the browser, then press Enter "
+            "to continue..."
+        )
 
-        # Execute the sleep via ActionExecutor (no snapshot diff expected)
-        result = await self._exec(action)
+        logger.info(f"\n{prompt}\n")
+
+        async def _await_enter():
+            await asyncio.to_thread(input, ">>> Press Enter to resume <<<\n")
+
+        try:
+            if timeout_sec is not None:
+                await asyncio.wait_for(_await_enter(), timeout=timeout_sec)
+                result_msg = "User resumed."
+            else:
+                await _await_enter()
+                result_msg = "User resumed."
+        except asyncio.TimeoutError:
+            result_msg = f"Timeout {timeout_sec}s reached, auto-resumed."
 
-        # Always return a *full* snapshot after the pause
         snapshot = await self._session.get_snapshot(
-            force_refresh=True, diff_only=False
+            force_refresh=True,
+            diff_only=False,
         )
-        return {"result": result, "snapshot": snapshot}
+
+        return {"result": result_msg, "snapshot": snapshot}
 
     # Helper to run through ActionExecutor
     async def _exec(self, action: Dict[str, Any]) -> str:

{camel_ai-0.2.69a3.dist-info → camel_ai-0.2.69a6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.69a3
+Version: 0.2.69a6
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel
@@ -176,7 +176,7 @@ Requires-Dist: types-pyyaml<7,>=6.0.12; extra == 'dev'
 Requires-Dist: types-requests<3,>=2.31.0; extra == 'dev'
 Requires-Dist: types-setuptools<70,>=69.2.0; extra == 'dev'
 Requires-Dist: types-tqdm<5,>=4.66.0; extra == 'dev'
-Requires-Dist: uv==0.6.5; extra == 'dev'
+Requires-Dist: uv<0.8,>=0.7.0; extra == 'dev'
 Provides-Extra: dev-tools
 Requires-Dist: aci-sdk>=1.0.0b1; extra == 'dev-tools'
 Requires-Dist: agentops<0.4,>=0.3.21; extra == 'dev-tools'
@@ -322,10 +322,6 @@ Requires-Dist: pytidb-experimental==0.0.1.dev4; extra == 'storage'
 Requires-Dist: qdrant-client<2,>=1.9.0; extra == 'storage'
 Requires-Dist: redis<6,>=5.0.6; extra == 'storage'
 Requires-Dist: weaviate-client>=4.15.0; extra == 'storage'
-Provides-Extra: test
-Requires-Dist: mock<6,>=5; extra == 'test'
-Requires-Dist: pytest-asyncio<0.24,>=0.23.0; extra == 'test'
-Requires-Dist: pytest<8,>=7; extra == 'test'
 Provides-Extra: web-tools
 Requires-Dist: apify-client<2,>=1.8.1; extra == 'web-tools'
 Requires-Dist: beautifulsoup4<5,>=4; extra == 'web-tools'

{camel_ai-0.2.69a3.dist-info → camel_ai-0.2.69a6.dist-info}/RECORD

@@ -1,4 +1,4 @@
-camel/__init__.py,sha256=Ryf5ZVEFpFI3TVgtC_wE9pClrhx8VR7g5d2M9lll1tU,901
+camel/__init__.py,sha256=A5ziO5SRxLf3bwmM8EImvN3SUQiBmZraUQyvySPP66A,901
 camel/generators.py,sha256=JRqj9_m1PF4qT6UtybzTQ-KBT9MJQt18OAAYvQ_fr2o,13844
 camel/human.py,sha256=Xg8x1cS5KK4bQ1SDByiHZnzsRpvRP-KZViNvmu38xo4,5475
 camel/logger.py,sha256=rZVeOVYuQ9RYJ5Tqyv0usqy0g4zaVEq4qSfZ9nd2640,5755
@@ -7,7 +7,7 @@ camel/agents/__init__.py,sha256=64weKqdvmpZcGWyVkO-OKASAmVUdrQjv60JApgPk_SA,1644
 camel/agents/_types.py,sha256=ryPRmEXnpNtbFT23GoAcwK-zxWWsIOqYu64mxMx_PhI,1430
 camel/agents/_utils.py,sha256=AR7Qqgbkmn4X2edYUQf1rdksGUyV5hm3iK1z-Dn0Mcg,6266
 camel/agents/base.py,sha256=c4bJYL3G3Z41SaFdMPMn8ZjLdFiFaVOFO6EQIfuCVR8,1124
-camel/agents/chat_agent.py,sha256=QFFyJOZ0fsyjjX_KwKsbp-SIFEFC6KTzMZ4dT98JsVg,80333
+camel/agents/chat_agent.py,sha256=x0-PgQ2ptvqHYv_nu2tcWdWn7szl8o6TzYjr739U4Rk,79407
 camel/agents/critic_agent.py,sha256=L6cTbYjyZB0DCa51tQ6LZLA6my8kHLC4nktHySH78H4,10433
 camel/agents/deductive_reasoner_agent.py,sha256=6BZGaq1hR6hKJuQtOfoYQnk_AkZpw_Mr7mUy2MspQgs,13540
 camel/agents/embodied_agent.py,sha256=XBxBu5ZMmSJ4B2U3Z7SMwvLlgp6yNpaBe8HNQmY9CZA,7536
@@ -134,7 +134,7 @@ camel/interpreters/__init__.py,sha256=NOQUsg7gR84zO8nBXu4JGUatsxSDJqZS6otltjXfop
 camel/interpreters/base.py,sha256=J3DVt_dGzq1v09-gn8j2XRgEM2WoPrhKFyH9koAjkCU,2281
 camel/interpreters/docker_interpreter.py,sha256=IK26JFvqsM-7dOkT29qVqFujw5LF83_-BdSWsIplw4M,11318
 camel/interpreters/e2b_interpreter.py,sha256=lNtIsVJWdSdqLoILZS8f5_7WlHI3n457RzLjmeOqH-A,5319
-camel/interpreters/internal_python_interpreter.py,sha256=TU4ITQTsR8TXsklN11xWEcCkv4jnOVUmnBbHIHCKggk,23362
+camel/interpreters/internal_python_interpreter.py,sha256=HjCIfB-HYv2cJz6nUg_8w53zHFB7DwSycqr7H22O_RI,24806
 camel/interpreters/interpreter_error.py,sha256=uEhcmHmmcajt5C9PLeHs21h1fE6cmyt23tCAGie1kTA,880
 camel/interpreters/ipython_interpreter.py,sha256=V-Z_nIwaKmmivv_gD6nwdzmqfBUW4IoN4vZ0IOaUTZU,6582
 camel/interpreters/subprocess_interpreter.py,sha256=DMLJIlTiHk0QA_pH5CXESHdJk-5olKo3aUh0KNECqJI,17759
@@ -178,7 +178,7 @@ camel/models/anthropic_model.py,sha256=m5J1-RabKyYf-2ejA7A8r4qbRLpS9oRtHWapzHs0B
 camel/models/aws_bedrock_model.py,sha256=bcQBiHVdVuJXyPEkSdymQlGx2zHIVj5d4ouFuF8CSY0,4670
 camel/models/azure_openai_model.py,sha256=FGQ6Cls-a7uzStsgPmBPffgm7TgTEzN3R2SWlAmiBeY,15164
 camel/models/base_audio_model.py,sha256=_VUWh1L3rh8mldNvM5R6jBOKtvmTeBKJyRxAdPJmPlY,3324
-camel/models/base_model.py,sha256=QKCgw16QVudV9nfaIGhyP2_73hu4FEdJHrF_wJO5mUc,14654
+camel/models/base_model.py,sha256=VpPsxG5UDfEhidHsk5GP9wbahoOW4sMU-7-pAc1rqE0,17335
 camel/models/cohere_model.py,sha256=V1sL8JpaOAVYOi5hAIXWdEex0Mr36_kx4-BEACQfN5o,17237
 camel/models/crynux_model.py,sha256=leEiFz1RcRtVJLJvYt_Ydyg5jkSk3VEJphgmHFz67bw,4118
 camel/models/deepseek_model.py,sha256=AV7rKl0mYwiHsAifxOlekpFGtbc0LMhb7jnI5_hPzBE,10802
@@ -273,7 +273,7 @@ camel/societies/workforce/__init__.py,sha256=bkTI-PE-MSK9AQ2V2gR6cR2WY-R7Jqy_NmX
 camel/societies/workforce/base.py,sha256=z2DmbTP5LL5-aCAAqglznQqCLfPmnyM5zD3w6jjtsb8,2175
 camel/societies/workforce/prompts.py,sha256=_l7OUkzH5p7KOd8HMZle9zB9W3jKza_Yb_6elFKiZ2s,11813
 camel/societies/workforce/role_playing_worker.py,sha256=pWPCtkLx-xbc4SWyZBfMwvWr-R5ZpANhN7g6PDuH8Po,7615
-camel/societies/workforce/single_agent_worker.py,sha256=5lF9zzxDJMCtELh6Y407m_D2bMAXMsY3yvY3_Bssd5A,14704
+camel/societies/workforce/single_agent_worker.py,sha256=ZDVq5doJUoUY0Uuvhkucf4U--y36q1We3p3c4TuoBSM,14627
 camel/societies/workforce/task_channel.py,sha256=uqQQI67Tr4awbR4bjZXdx8_4gL6-ON5IjQk_H_ryqT4,7431
 camel/societies/workforce/utils.py,sha256=Gjlz7pLo4r1b6iNHtlIMxeEuat4d6tEEQMI40JAU3kY,6190
 camel/societies/workforce/worker.py,sha256=36tkOyz4G2wfBdrFjt9NBPXsx4UbE6uL5on8sP2aoqk,6414
@@ -311,7 +311,7 @@ camel/terminators/__init__.py,sha256=t8uqrkUnXEOYMXQDgaBkMFJ0EXFKI0kmx4cUimli3Ls
 camel/terminators/base.py,sha256=xmJzERX7GdSXcxZjAHHODa0rOxRChMSRboDCNHWSscs,1511
 camel/terminators/response_terminator.py,sha256=n3G5KP6Oj7-7WlRN0yFcrtLpqAJKaKS0bmhrWlFfCgQ,4982
 camel/terminators/token_limit_terminator.py,sha256=YWv6ZR8R9yI2Qnf_3xES5bEE_O5bb2CxQ0EUXfMh34c,2118
-camel/toolkits/__init__.py,sha256=2Cf42WOw5v4kKo8WyoyHILoqtPdfV7_Xx4YuFcZt76o,5121
+camel/toolkits/__init__.py,sha256=hgg25B07IzPdJWmDVm_XQzLRHjtiNwCaroJDfvAiDOQ,5356
 camel/toolkits/aci_toolkit.py,sha256=39AsXloBb16hHB7DKi6mFU6NPZ3iVpM2FZgaP4o4eLE,16060
 camel/toolkits/arxiv_toolkit.py,sha256=mw629nIN_ozaAxNv3nbvhonJKNI2-97ScRCBS3gVqNo,6297
 camel/toolkits/ask_news_toolkit.py,sha256=WfWaqwEo1Apbil3-Rb5y65Ws43NU4rAFWZu5VHe4los,23448
@@ -322,9 +322,11 @@ camel/toolkits/bohrium_toolkit.py,sha256=453t-m0h0IGjurG6tCHUejGzfRAN2SAkhIoY8V-
 camel/toolkits/browser_toolkit.py,sha256=Ntn_LmCrhqqIBWq9HtiIKw-M0cL5ebn74Ej1GBoZiC8,44400
 camel/toolkits/browser_toolkit_commons.py,sha256=uuc1V5tN3YJmTSe6NHAVJqwsL4iYD7IiSZWxPLYW67A,22196
 camel/toolkits/code_execution.py,sha256=ptexsx8t9teGse8ROnAHCYaLlDg843p-9p1ek-8JpWU,5620
+camel/toolkits/craw4ai_toolkit.py,sha256=oJOjErSqMMpVKAtyjL8YmV9hnYl3gnZ2RReiOM4E5Rk,2665
 camel/toolkits/dalle_toolkit.py,sha256=GSnV7reQsVmhMi9sbQy1Ks_5Vs57Dlir_AbT2PPCZwo,6153
 camel/toolkits/dappier_toolkit.py,sha256=OEHOYXX_oXhgbVtWYAy13nO9uXf9i5qEXSwY4PexNFg,8194
 camel/toolkits/data_commons_toolkit.py,sha256=aHZUSL1ACpnYGaf1rE2csVKTmXTmN8lMGRUBYhZ_YEk,14168
+camel/toolkits/edgeone_pages_mcp_toolkit.py,sha256=1TFpAGHUNLggFQeN1OEw7P5laijwnlrCkfxBtgxFuUY,2331
 camel/toolkits/excel_toolkit.py,sha256=DSjBXl24_LrJubGFFmB_vqliKzzWTbT1TH309YQVUO8,6653
 camel/toolkits/file_write_toolkit.py,sha256=i1CivjvqTpHakYK_EynNvNikjZZYsusxkjT2v-f9EYc,16473
 camel/toolkits/function_tool.py,sha256=xCDzjxTRCVj_kmbnMFBuwK-3NuzM4JNe_kv9HLtjnIA,33644
@@ -337,6 +339,7 @@ camel/toolkits/image_analysis_toolkit.py,sha256=IC36mtytgyMSW20IImIZDgQPsgPxmxZG
 camel/toolkits/jina_reranker_toolkit.py,sha256=0OWUlSqRNYYmD5EQZW7OX87lfmzLRjjDmHRyqHU6dmU,11963
 camel/toolkits/klavis_toolkit.py,sha256=ZKerhgz5e-AV-iv0ftf07HgWikknIHjB3EOQswfuR80,9864
 camel/toolkits/linkedin_toolkit.py,sha256=wn4eXwYYlVA7doTna7k7WYhUqTBF83W79S-UJs_IQr0,8065
+camel/toolkits/markitdown_toolkit.py,sha256=7jxPbaE2CIq1FpT41q52Fznw-Gx05ITWn1t9O5IytA4,2867
 camel/toolkits/math_toolkit.py,sha256=KdI8AJ9Dbq5cfWboAYJUYgSkmADMCO5eZ6yqYkWuiIQ,3686
 camel/toolkits/mcp_toolkit.py,sha256=czGYgZ-Vd9NdAcPe_hoA7ZYxSV2QKhsxuJNZNg3Rof4,25459
 camel/toolkits/memory_toolkit.py,sha256=TeKYd5UMwgjVpuS2orb-ocFL13eUNKujvrFOruDCpm8,4436
@@ -374,7 +377,7 @@ camel/toolkits/zapier_toolkit.py,sha256=A83y1UcfuopH7Fx82pORzypl1StbhBjB2HhyOqYa
 camel/toolkits/non_visual_browser_toolkit/__init__.py,sha256=mXAjf6qkl8BgJrBKPR5d2C3B2m4pOHvq6sRavmgOweA,812
 camel/toolkits/non_visual_browser_toolkit/actions.py,sha256=pue7Q5ZGLhqcmbkuahrN_JBYdeV0xtqu9i4gr9mqGWU,7113
 camel/toolkits/non_visual_browser_toolkit/agent.py,sha256=y6sAWlPXScVn7f2bPueS8yd8IQ3CkJ0HutP4DChs6P8,10330
-camel/toolkits/non_visual_browser_toolkit/browser_non_visual_toolkit.py,sha256=YM1mxicA56tdd8qt3WUJMCPjruIzRCvYRZA_q7tC4qk,14002
+camel/toolkits/non_visual_browser_toolkit/browser_non_visual_toolkit.py,sha256=GsaJ9_8M9n7D-SJIwC2TeTL5Yon76ueTWikiMZ7LwHE,15999
 camel/toolkits/non_visual_browser_toolkit/nv_browser_session.py,sha256=ylN5DgZzgG7biV99ufyFBfjGf0cMlrtzX-3wO409EI4,7304
 camel/toolkits/non_visual_browser_toolkit/snapshot.js,sha256=4MHtRGlbvJWxs1gQC9RS0ButppPeLZPIHTwZ7AS7hFQ,6627
 camel/toolkits/non_visual_browser_toolkit/snapshot.py,sha256=jnnuIm1VqeoTAAw96kKOZum17-mwghPsm0uRSFoYvxU,7708
@@ -431,7 +434,7 @@ camel/verifiers/math_verifier.py,sha256=tA1D4S0sm8nsWISevxSN0hvSVtIUpqmJhzqfbuMo
 camel/verifiers/models.py,sha256=GdxYPr7UxNrR1577yW4kyroRcLGfd-H1GXgv8potDWU,2471
 camel/verifiers/physics_verifier.py,sha256=c1grrRddcrVN7szkxhv2QirwY9viIRSITWeWFF5HmLs,30187
 camel/verifiers/python_verifier.py,sha256=ogTz77wODfEcDN4tMVtiSkRQyoiZbHPY2fKybn59lHw,20558
-camel_ai-0.2.69a3.dist-info/METADATA,sha256=IqaSVunoJDMvh0Hp12M5MItps4OkEnqbmPx4NVi_xZw,45047
-camel_ai-0.2.69a3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-camel_ai-0.2.69a3.dist-info/licenses/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
-camel_ai-0.2.69a3.dist-info/RECORD,,
+camel_ai-0.2.69a6.dist-info/METADATA,sha256=LkkXRk2a3WfankzmWhW2GWnrWQzTA6gNgGpAnq50fvA,44882
+camel_ai-0.2.69a6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+camel_ai-0.2.69a6.dist-info/licenses/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
+camel_ai-0.2.69a6.dist-info/RECORD,,