camel-ai 0.2.68__py3-none-any.whl → 0.2.69a1__py3-none-any.whl

camel/tasks/task.py

@@ -25,10 +25,12 @@ from typing import (
     Union,
 )
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 if TYPE_CHECKING:
     from camel.agents import ChatAgent
+import uuid
+
 from camel.logger import get_logger
 from camel.messages import BaseMessage
 from camel.prompts import TextPrompt
@@ -142,27 +144,29 @@ class Task(BaseModel):
         content (str): string content for task.
         id (str): An unique string identifier for the task. This should
             ideally be provided by the provider/model which created the task.
-            (default: :obj: `""`)
+            (default: :obj:`uuid.uuid4()`)
         state (TaskState): The state which should be OPEN, RUNNING, DONE or
-            DELETED. (default: :obj: `TaskState.OPEN`)
-        type (Optional[str]): task type. (default: :obj: `None`)
+            DELETED. (default: :obj:`TaskState.FAILED`)
+        type (Optional[str]): task type. (default: :obj:`None`)
         parent (Optional[Task]): The parent task, None for root task.
-            (default: :obj: `None`)
+            (default: :obj:`None`)
         subtasks (List[Task]): The childrent sub-tasks for the task.
-            (default: :obj: `[]`)
+            (default: :obj:`[]`)
         result (Optional[str]): The answer for the task.
-            (default: :obj: `""`)
+            (default: :obj:`""`)
         failure_count (int): The failure count for the task.
-            (default: :obj: `0`)
+            (default: :obj:`0`)
         additional_info (Optional[Dict[str, Any]]): Additional information for
-            the task. (default: :obj: `None`)
+            the task. (default: :obj:`None`)
     """
 
     content: str
 
-    id: str = ""
+    id: str = Field(default_factory=lambda: str(uuid.uuid4()))
 
-    state: TaskState = TaskState.OPEN
+    state: TaskState = (
+        TaskState.FAILED
+    )  # TODO: Add logic for OPEN in workforce.py
 
     type: Optional[str] = None
 
@@ -204,7 +208,9 @@ class Task(BaseModel):
 
     def reset(self):
         r"""Reset Task to initial state."""
-        self.state = TaskState.OPEN
+        self.state = (
+            TaskState.FAILED
+        )  # TODO: Add logic for OPEN in workforce.py
         self.result = ""
 
     def update_result(self, result: str):

camel/toolkits/__init__.py

@@ -77,6 +77,7 @@ from .aci_toolkit import ACIToolkit
 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
 
 
 __all__ = [
@@ -142,4 +143,5 @@ __all__ = [
     'WolframAlphaToolkit',
     'BohriumToolkit',
     'TaskPlanningToolkit',
+    'BrowserNonVisualToolkit',
 ]

camel/toolkits/aci_toolkit.py

@@ -48,14 +48,14 @@ class ACIToolkit(BaseToolkit):
 
         Args:
             api_key (Optional[str]): The API key for authentication.
-                (default: :obj: `None`)
+                (default: :obj:`None`)
             base_url (Optional[str]): The base URL for the ACI API.
-                (default: :obj: `None`)
+                (default: :obj:`None`)
             linked_account_owner_id (Optional[str]): ID of the owner of the
                 linked account, e.g., "johndoe"
-                (default: :obj: `None`)
+                (default: :obj:`None`)
             timeout (Optional[float]): Request timeout.
-                (default: :obj: `None`)
+                (default: :obj:`None`)
         """
         from aci import ACI
 
@@ -80,20 +80,20 @@ class ACIToolkit(BaseToolkit):
         Args:
             intent (Optional[str]): Search results will be sorted by relevance
                 to this intent.
-                (default: :obj: `None`)
+                (default: :obj:`None`)
             allowed_app_only (bool): If true, only return apps that
                 are allowed by the agent/accessor, identified by the api key.
-                (default: :obj: `True`)
+                (default: :obj:`True`)
             include_functions (bool): If true, include functions
                 (name and description) in the search results.
-                (default: :obj: `False`)
+                (default: :obj:`False`)
             categories (Optional[List[str]]): List of categories to filter the
                 search results. Defaults to an empty list.
-                (default: :obj: `None`)
+                (default: :obj:`None`)
             limit (Optional[int]): Maximum number of results to return.
-                (default: :obj: `10`)
+                (default: :obj:`10`)
             offset (Optional[int]): Offset for pagination.
-                (default: :obj: `0`)
+                (default: :obj:`0`)
 
         Returns:
             Optional[List[AppBasic]]: List of matching apps if successful,
@@ -123,10 +123,10 @@ class ACIToolkit(BaseToolkit):
 
         Args:
             app_names (Optional[List[str]]): List of app names to filter the
-                results. (default: :obj: `None`)
+                results. (default: :obj:`None`)
             limit (Optional[int]): Maximum number of results to return.
-                (default: :obj: `10`)
-            offset (Optional[int]): Offset for pagination. (default: :obj: `0`)
+                (default: :obj:`10`)
+            offset (Optional[int]): Offset for pagination. (default: :obj:`0`)
 
         Returns:
             Union[List[AppConfiguration], str]: List of configured apps if
@@ -356,15 +356,15 @@ class ACIToolkit(BaseToolkit):
 
         Args:
             app_names (Optional[List[str]]): List of app names to filter the
-                search results. (default: :obj: `None`)
+                search results. (default: :obj:`None`)
             intent (Optional[str]): The search query/intent.
-                (default: :obj: `None`)
+                (default: :obj:`None`)
             allowed_apps_only (bool): If true, only return
-                functions from allowed apps. (default: :obj: `True`)
+                functions from allowed apps. (default: :obj:`True`)
             limit (Optional[int]): Maximum number of results to return.
-                (default: :obj: `10`)
+                (default: :obj:`10`)
             offset (Optional[int]): Offset for pagination.
-                (default: :obj: `0`)
+                (default: :obj:`0`)
 
         Returns:
             List[Dict]: List of matching functions
@@ -395,7 +395,7 @@ class ACIToolkit(BaseToolkit):
                 owner id in the ACI dashboard (https://platform.aci.dev).
             allowed_apps_only (bool): If true, only returns functions/apps
                 that are allowed to be used by the agent/accessor, identified
-                by the api key. (default: :obj: `False`)
+                by the api key. (default: :obj:`False`)
 
         Returns:
             Dict: Result of the function execution

camel/toolkits/arxiv_toolkit.py

@@ -49,9 +49,9 @@ class ArxivToolkit(BaseToolkit):
             query (str): The search query string used to search for papers on
                 arXiv.
             paper_ids (List[str], optional): A list of specific arXiv paper
-                IDs to search for. (default: :obj: `None`)
+                IDs to search for. (default: :obj:`None`)
             max_results (int, optional): The maximum number of search results
-                to retrieve. (default: :obj: `5`)
+                to retrieve. (default: :obj:`5`)
 
         Returns:
             Generator: A generator that yields results from the arXiv search
@@ -80,9 +80,9 @@ class ArxivToolkit(BaseToolkit):
         Args:
             query (str): The search query string.
             paper_ids (List[str], optional): A list of specific arXiv paper
-                IDs to search for. (default: :obj: `None`)
+                IDs to search for. (default: :obj:`None`)
             max_results (int, optional): The maximum number of search results
-                to return. (default: :obj: `5`)
+                to return. (default: :obj:`5`)
 
         Returns:
             List[Dict[str, str]]: A list of dictionaries, each containing
@@ -138,9 +138,9 @@ class ArxivToolkit(BaseToolkit):
         Args:
             query (str): The search query string.
             paper_ids (List[str], optional): A list of specific arXiv paper
-                IDs to download. (default: :obj: `None`)
+                IDs to download. (default: :obj:`None`)
             max_results (int, optional): The maximum number of search results
-                to download. (default: :obj: `5`)
+                to download. (default: :obj:`5`)
             output_dir (str, optional): The directory to save the downloaded
                 PDFs. Defaults to the current directory.
 

camel/toolkits/dappier_toolkit.py

@@ -126,22 +126,22 @@ class DappierToolkit(BaseToolkit):
             query (str): The user query for retrieving recommendations.
             data_model_id (str, optional): The data model ID to use for
                 recommendations. Data model IDs always start with the prefix
-                "dm_". (default: :obj: `dm_01j0pb465keqmatq9k83dthx34`)
+                "dm_". (default: :obj:`dm_01j0pb465keqmatq9k83dthx34`)
             similarity_top_k (int, optional): The number of top documents to
-                retrieve based on similarity. (default: :obj: `9`)
+                retrieve based on similarity. (default: :obj:`9`)
             ref (Optional[str], optional): The site domain where AI
-                recommendations should be displayed. (default: :obj: `None`)
+                recommendations should be displayed. (default: :obj:`None`)
             num_articles_ref (int, optional): The minimum number of articles
                 to return from the specified reference domain (`ref`). The
                 remaining articles will come from other sites in the RAG
-                model. (default: :obj: `0`)
+                model. (default: :obj:`0`)
             search_algorithm (Literal[
                 "most_recent",
                 "semantic",
                 "most_recent_semantic",
                 "trending",
                 ], optional): The search algorithm to use for retrieving
-                articles. (default: :obj: `most_recent`)
+                articles. (default: :obj:`most_recent`)
 
         Returns:
             List[Dict[str, str]]: A list of recommended articles or content

camel/toolkits/file_write_toolkit.py

@@ -50,11 +50,11 @@ class FileWriteToolkit(BaseToolkit):
             output_dir (str): The default directory for output files.
                 Defaults to the current working directory.
             timeout (Optional[float]): The timeout for the toolkit.
-                (default: :obj: `None`)
+                (default: :obj:`None`)
             default_encoding (str): Default character encoding for text
-                operations. (default: :obj: `utf-8`)
+                operations. (default: :obj:`utf-8`)
             backup_enabled (bool): Whether to create backups of existing files
-                before overwriting. (default: :obj: `True`)
+                before overwriting. (default: :obj:`True`)
         """
         super().__init__(timeout=timeout)
         self.output_dir = Path(output_dir).resolve()
@@ -96,7 +96,7 @@ class FileWriteToolkit(BaseToolkit):
         Args:
             file_path (Path): The target file path.
             content (str): The text content to write.
-            encoding (str): Character encoding to use. (default: :obj: `utf-8`)
+            encoding (str): Character encoding to use. (default: :obj:`utf-8`)
         """
         with file_path.open("w", encoding=encoding) as f:
             f.write(content)
@@ -157,7 +157,7 @@ class FileWriteToolkit(BaseToolkit):
             content (str): The text content to write.
             use_latex (bool): Whether to use LaTeX for rendering. (requires
                 LaTeX toolchain). If False, uses FPDF for simpler PDF
-                generation. (default: :obj: `False`)
+                generation. (default: :obj:`False`)
 
         Raises:
             RuntimeError: If the 'pylatex' or 'fpdf' library is not installed
@@ -236,7 +236,7 @@ class FileWriteToolkit(BaseToolkit):
             file_path (Path): The target file path.
             content (Union[str, List[List]]): The CSV content as a string or
                 list of lists.
-            encoding (str): Character encoding to use. (default: :obj: `utf-8`)
+            encoding (str): Character encoding to use. (default: :obj:`utf-8`)
         """
         import csv
 
@@ -259,7 +259,7 @@ class FileWriteToolkit(BaseToolkit):
         Args:
             file_path (Path): The target file path.
             content (str): The JSON content as a string.
-            encoding (str): Character encoding to use. (default: :obj: `utf-8`)
+            encoding (str): Character encoding to use. (default: :obj:`utf-8`)
         """
         import json
 
@@ -288,7 +288,7 @@ class FileWriteToolkit(BaseToolkit):
         Args:
             file_path (Path): The target file path.
             content (str): The YAML content as a string.
-            encoding (str): Character encoding to use. (default: :obj: `utf-8`)
+            encoding (str): Character encoding to use. (default: :obj:`utf-8`)
         """
         with file_path.open("w", encoding=encoding) as f:
             f.write(content)
@@ -302,7 +302,7 @@ class FileWriteToolkit(BaseToolkit):
         Args:
             file_path (Path): The target file path.
             content (str): The HTML content to write.
-            encoding (str): Character encoding to use. (default: :obj: `utf-8`)
+            encoding (str): Character encoding to use. (default: :obj:`utf-8`)
         """
         with file_path.open("w", encoding=encoding) as f:
             f.write(content)
@@ -316,7 +316,7 @@ class FileWriteToolkit(BaseToolkit):
         Args:
             file_path (Path): The target file path.
             content (str): The Markdown content to write.
-            encoding (str): Character encoding to use. (default: :obj: `utf-8`)
+            encoding (str): Character encoding to use. (default: :obj:`utf-8`)
         """
         with file_path.open("w", encoding=encoding) as f:
             f.write(content)

camel/toolkits/github_toolkit.py

@@ -158,7 +158,7 @@ class GithubToolkit(BaseToolkit):
         Args:
             repo_name (str): The name of the GitHub repository.
             state (Literal["open", "closed", "all"]): The state of pull
-                requests to retrieve. (default: :obj: `all`)
+                requests to retrieve. (default: :obj:`all`)
                 Options are:
                 - "open": Retrieve only open pull requests.
                 - "closed": Retrieve only closed pull requests.
@@ -202,7 +202,7 @@ class GithubToolkit(BaseToolkit):
         Args:
             repo_name (str): The name of the GitHub repository.
             state (Literal["open", "closed", "all"]): The state of pull
-                requests to retrieve. (default: :obj: `all`)
+                requests to retrieve. (default: :obj:`all`)
                 Options are:
                 - "open": Retrieve only open pull requests.
                 - "closed": Retrieve only closed pull requests.
@@ -285,7 +285,7 @@ class GithubToolkit(BaseToolkit):
             repo_name (str): The name of the GitHub repository.
             path (str): The repository path to start the traversal from.
                 empty string means starts from the root directory.
-                (default: :obj: `""`)
+                (default: :obj:`""`)
 
         Returns:
             List[str]: A list of file paths within the specified directory

camel/toolkits/non_visual_browser_toolkit/__init__.py

@@ -0,0 +1,18 @@
+# ========= 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 .browser_non_visual_toolkit import BrowserNonVisualToolkit
+
+__all__ = [
+    "BrowserNonVisualToolkit",
+]

camel/toolkits/non_visual_browser_toolkit/actions.py

@@ -0,0 +1,196 @@
+# ========= 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. =========
+import asyncio
+from typing import TYPE_CHECKING, Any, Dict
+
+if TYPE_CHECKING:
+    from playwright.async_api import Page
+
+
+class ActionExecutor:
+    r"""Executes high-level actions (click, type …) on a Playwright Page."""
+
+    # Configuration constants
+    DEFAULT_TIMEOUT = 5000  # 5 seconds
+    SHORT_TIMEOUT = 2000  # 2 seconds
+
+    def __init__(self, page: "Page"):
+        self.page = page
+
+    # ------------------------------------------------------------------
+    # Public helpers
+    # ------------------------------------------------------------------
+    async def execute(self, action: Dict[str, Any]) -> str:
+        if not action:
+            return "No action to execute"
+
+        action_type = action.get("type")
+        if not action_type:
+            return "Error: action has no type"
+
+        try:
+            # small helper to ensure basic stability
+            await self._wait_dom_stable()
+
+            handler = {
+                "click": self._click,
+                "type": self._type,
+                "select": self._select,
+                "wait": self._wait,
+                "extract": self._extract,
+                "scroll": self._scroll,
+                "enter": self._enter,
+            }.get(action_type)
+
+            if handler is None:
+                return f"Error: Unknown action type '{action_type}'"
+
+            return await handler(action)
+        except Exception as exc:
+            return f"Error executing {action_type}: {exc}"
+
+    # ------------------------------------------------------------------
+    # Internal handlers
+    # ------------------------------------------------------------------
+    async def _click(self, action: Dict[str, Any]) -> str:
+        ref = action.get("ref")
+        text = action.get("text")
+        selector = action.get("selector")
+        if not (ref or text or selector):
+            return "Error: click requires ref/text/selector"
+
+        strategies = []
+        if selector:
+            strategies.append(selector)
+        if text:
+            strategies.append(f'text="{text}"')
+        if ref:
+            strategies.append(f"[aria-ref='{ref}']")
+
+        for sel in strategies:
+            try:
+                if await self.page.locator(sel).count() > 0:
+                    await self.page.click(
+                        sel, timeout=self.SHORT_TIMEOUT, force=True
+                    )
+                    return f"Clicked element via {sel}"
+            except Exception:
+                pass
+        return "Error: Could not click element"
+
+    async def _type(self, action: Dict[str, Any]) -> str:
+        ref = action.get("ref")
+        selector = action.get("selector")
+        text = action.get("text", "")
+        if not (ref or selector):
+            return "Error: type requires ref/selector"
+        target = selector or f"[aria-ref='{ref}']"
+        try:
+            await self.page.fill(target, text, timeout=self.SHORT_TIMEOUT)
+            return f"Typed '{text}' into {target}"
+        except Exception as exc:
+            return f"Type failed: {exc}"
+
+    async def _select(self, action: Dict[str, Any]) -> str:
+        ref = action.get("ref")
+        selector = action.get("selector")
+        value = action.get("value", "")
+        if not (ref or selector):
+            return "Error: select requires ref/selector"
+        target = selector or f"[aria-ref='{ref}']"
+        try:
+            await self.page.select_option(
+                target, value, timeout=self.DEFAULT_TIMEOUT
+            )
+            return f"Selected '{value}' in {target}"
+        except Exception as exc:
+            return f"Select failed: {exc}"
+
+    async def _wait(self, action: Dict[str, Any]) -> str:
+        if "timeout" in action:
+            ms = action["timeout"]
+            await asyncio.sleep(ms / 1000)
+            return f"Waited {ms}ms"
+        if "selector" in action:
+            sel = action["selector"]
+            await self.page.wait_for_selector(
+                sel, timeout=self.DEFAULT_TIMEOUT
+            )
+            return f"Waited for {sel}"
+        return "Error: wait requires timeout/selector"
+
+    async def _extract(self, action: Dict[str, Any]) -> str:
+        ref = action.get("ref")
+        if not ref:
+            return "Error: extract requires ref"
+        target = f"[aria-ref='{ref}']"
+        await self.page.wait_for_selector(target, timeout=self.DEFAULT_TIMEOUT)
+        txt = await self.page.text_content(target)
+        return f"Extracted: {txt[:100] if txt else 'None'}"
+
+    async def _scroll(self, action: Dict[str, Any]) -> str:
+        direction = action.get("direction", "down")
+        amount = action.get("amount", 300)
+
+        # Validate inputs to prevent injection
+        if direction not in ("up", "down"):
+            return "Error: direction must be 'up' or 'down'"
+
+        try:
+            # Safely convert amount to integer and clamp to reasonable range
+            amount_int = int(amount)
+            amount_int = max(
+                -5000, min(5000, amount_int)
+            )  # Clamp between -5000 and 5000
+        except (ValueError, TypeError):
+            return "Error: amount must be a valid number"
+
+        # Use safe evaluation with bound parameters
+        scroll_offset = amount_int if direction == "down" else -amount_int
+        await self.page.evaluate(f"window.scrollBy(0, {scroll_offset})")
+        await asyncio.sleep(0.5)
+        return f"Scrolled {direction} by {abs(amount_int)}px"
+
+    async def _enter(self, action: Dict[str, Any]) -> str:
+        ref = action.get("ref")
+        selector = action.get("selector")
+        if ref:
+            await self.page.focus(f"[aria-ref='{ref}']")
+        elif selector:
+            await self.page.focus(selector)
+        await self.page.keyboard.press("Enter")
+        await asyncio.sleep(0.3)
+        return "Pressed Enter"
+
+    # utilities
+    async def _wait_dom_stable(self) -> None:
+        try:
+            await self.page.wait_for_load_state(
+                'domcontentloaded', timeout=self.SHORT_TIMEOUT
+            )
+        except Exception:
+            pass
+
+    # static helpers
+    @staticmethod
+    def should_update_snapshot(action: Dict[str, Any]) -> bool:
+        change_types = {
+            "click",
+            "type",
+            "select",
+            "scroll",
+            "navigate",
+            "enter",
+        }
+        return action.get("type") in change_types