camel-ai 0.2.75a5__py3-none-any.whl → 0.2.76__py3-none-any.whl

camel/toolkits/edgeone_pages_mcp_toolkit.py

@@ -12,14 +12,12 @@
 # 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 typing import Optional
 
 from .mcp_toolkit import MCPToolkit
 
 
-class EdgeOnePagesMCPToolkit(BaseToolkit):
+class EdgeOnePagesMCPToolkit(MCPToolkit):
     r"""EdgeOnePagesMCPToolkit provides an interface for interacting with
     EdgeOne pages using the EdgeOne Pages MCP server.
 
@@ -38,32 +36,14 @@ class EdgeOnePagesMCPToolkit(BaseToolkit):
             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"],
-                    }
+        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()
+        # Initialize parent MCPToolkit with EdgeOne Pages configuration
+        super().__init__(config_dict=config_dict, timeout=timeout)

camel/toolkits/{file_write_toolkit.py → file_toolkit.py}

@@ -15,7 +15,7 @@ import os
 import re
 from datetime import datetime
 from pathlib import Path
-from typing import List, Optional, Tuple, Union
+from typing import Dict, List, Optional, Tuple, Union
 
 from camel.logger import get_logger
 from camel.toolkits.base import BaseToolkit
@@ -26,14 +26,17 @@ logger = get_logger(__name__)
 
 
 @MCPServer()
-class FileWriteToolkit(BaseToolkit):
-    r"""A toolkit for creating, writing, and modifying text in files.
-
-    This class provides cross-platform (macOS, Linux, Windows) support for
-    writing to various file formats (Markdown, DOCX, PDF, and plaintext),
-    replacing text in existing files, automatic filename uniquification to
-    prevent overwrites, custom encoding and enhanced formatting options for
-    specialized formats.
+class FileToolkit(BaseToolkit):
+    r"""A comprehensive toolkit for file operations including reading,
+    writing, and editing files.
+
+    This class provides cross-platform (macOS, Linux, Windows) support for:
+    - Reading various file formats (text, JSON, YAML, PDF, DOCX)
+    - Writing to multiple formats (Markdown, DOCX, PDF, plaintext, JSON,
+      YAML, CSV, HTML)
+    - Editing and modifying existing files with content replacement
+    - Automatic backup creation before modifications
+    - Custom encoding and enhanced formatting options
     """
 
     def __init__(
@@ -126,36 +129,32 @@ class FileWriteToolkit(BaseToolkit):
         with file_path.open("w", encoding=encoding) as f:
             f.write(content)
 
-    def _generate_unique_filename(self, file_path: Path) -> Path:
-        r"""Generate a unique filename if the target file already exists.
+    def _create_backup(self, file_path: Path) -> Optional[Path]:
+        r"""Create a backup of the file if it exists and backup is enabled.
 
         Args:
-            file_path (Path): The original file path.
+            file_path (Path): The file path to backup.
 
         Returns:
-            Path: A unique file path that doesn't exist yet.
+            Optional[Path]: Path to the backup file if created, None otherwise.
         """
-        if not file_path.exists():
-            return file_path
+        if not self.backup_enabled or not file_path.exists():
+            return None
 
-        # Generate unique filename with timestamp and counter
+        # Generate backup filename with .bak extension and timestamp
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        stem = file_path.stem
-        suffix = file_path.suffix
-        parent = file_path.parent
-
-        # First try with timestamp
-        new_path = parent / f"{stem}_{timestamp}{suffix}"
-        if not new_path.exists():
-            return new_path
-
-        # If timestamp version exists, add counter
-        counter = 1
-        while True:
-            new_path = parent / f"{stem}_{timestamp}_{counter}{suffix}"
-            if not new_path.exists():
-                return new_path
-            counter += 1
+        backup_path = file_path.parent / f"{file_path.name}.{timestamp}.bak"
+
+        # Copy the file to backup location
+        import shutil
+
+        try:
+            shutil.copy2(file_path, backup_path)
+            logger.info(f"Created backup: {backup_path}")
+            return backup_path
+        except Exception as e:
+            logger.warning(f"Failed to create backup: {e}")
+            return None
 
     def _write_docx_file(self, file_path: Path, content: str) -> None:
         r"""Write text content to a DOCX file with default formatting.
@@ -1006,8 +1005,9 @@ class FileWriteToolkit(BaseToolkit):
         file_path = self._resolve_filepath(filename)
         file_path.parent.mkdir(parents=True, exist_ok=True)
 
-        # Generate unique filename if file exists
-        file_path = self._generate_unique_filename(file_path)
+        # Create backup of existing file if backup is enabled
+        if file_path.exists() and self.backup_enabled:
+            self._create_backup(file_path)
 
         extension = file_path.suffix.lower()
 
@@ -1062,6 +1062,144 @@ class FileWriteToolkit(BaseToolkit):
             logger.error(error_msg)
             return error_msg
 
+    # ----------------------------------------------
+    # Read File Functions
+    # ----------------------------------------------
+    def read_file(
+        self, file_paths: Union[str, List[str]]
+    ) -> Union[str, Dict[str, str]]:
+        r"""Read and return content of one or more files using MarkItDown
+        for better format support.
+
+        This method uses MarkItDownLoader to convert various file formats
+        to Markdown. It supports a wide range of formats including:
+        - 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, .md)
+        - ZIP archives (.zip)
+
+        Args:
+            file_paths (Union[str, List[str]]): A single file path or a list
+                of file paths to read. Paths can be relative or absolute.
+                If relative, they will be resolved relative to the working
+                directory.
+
+        Returns:
+            Union[str, Dict[str, str]]:
+                - If a single file path is provided: Returns the content as
+                  a string.
+                - If multiple file paths are provided: Returns a dictionary
+                  where keys are file paths and values are the corresponding
+                  content in Markdown format.
+                If conversion fails, returns an error message.
+        """
+        from camel.loaders.markitdown import MarkItDownLoader
+
+        try:
+            # Handle single file path for backward compatibility
+            if isinstance(file_paths, str):
+                resolved_path = self._resolve_filepath(file_paths)
+
+                # Use MarkItDownLoader to convert the file
+                result = MarkItDownLoader().convert_files(
+                    file_paths=[str(resolved_path)], parallel=False
+                )
+
+                # Return the converted content or error message
+                return result.get(
+                    str(resolved_path), f"Failed to read file: {resolved_path}"
+                )
+
+            # Handle multiple file paths
+            else:
+                resolved_paths = [
+                    str(self._resolve_filepath(fp)) for fp in file_paths
+                ]
+
+                # Use MarkItDownLoader to convert files in parallel
+                result = MarkItDownLoader().convert_files(
+                    file_paths=resolved_paths, parallel=True
+                )
+
+                # Map back to original paths if needed
+                return_dict = {}
+                for original, resolved in zip(file_paths, resolved_paths):
+                    return_dict[original] = result.get(
+                        resolved, f"Failed to read file: {resolved}"
+                    )
+
+                return return_dict
+
+        except Exception as e:
+            return f"Error reading file(s): {e}"
+
+    # ----------------------------------------------
+    # Edit File Functions
+    # ----------------------------------------------
+    def edit_file(
+        self, file_path: str, old_content: str, new_content: str
+    ) -> str:
+        r"""Edit a file by replacing specified content.
+
+        This method performs simple text replacement in files. It reads
+        the file, replaces all occurrences of old_content with new_content,
+        and writes the result back.
+
+        Args:
+            file_path (str): The path to the file to edit. Can be
+                relative or absolute. If relative, it will be resolved
+                relative to the working directory.
+            old_content (str): The exact text to find and replace.
+            new_content (str): The text to replace old_content with.
+
+        Returns:
+            str: A success message if the edit was successful, or an
+                error message if the content wasn't found or an error occurred.
+        """
+        try:
+            working_path = self._resolve_filepath(file_path)
+
+            if not working_path.exists():
+                return f"Error: File {working_path} does not exist"
+
+            # Create backup before editing if enabled
+            self._create_backup(working_path)
+
+            # Read the file content
+            try:
+                file_text = working_path.read_text(
+                    encoding=self.default_encoding
+                )
+            except Exception as e:
+                return f"Error reading file: {e}"
+
+            # Check if the old_content exists in the file
+            if old_content not in file_text:
+                return (
+                    f"No replacement performed: '{old_content}' not found in "
+                    f"{working_path}."
+                )
+
+            # Replace the content
+            new_file_text = file_text.replace(old_content, new_content)
+
+            # Write back to file
+            try:
+                working_path.write_text(
+                    new_file_text, encoding=self.default_encoding
+                )
+                return f"Successfully edited {working_path}"
+            except Exception as e:
+                return f"Error writing file: {e}"
+
+        except Exception as e:
+            return f"Error editing file: {e}"
+
     def get_tools(self) -> List[FunctionTool]:
         r"""Return a list of FunctionTool objects representing the functions
         in the toolkit.
@@ -1072,4 +1210,26 @@ class FileWriteToolkit(BaseToolkit):
         """
         return [
             FunctionTool(self.write_to_file),
+            FunctionTool(self.read_file),
+            FunctionTool(self.edit_file),
         ]
+
+
+# Backward compatibility: FileWriteToolkit as deprecated alias
+class FileWriteToolkit(FileToolkit):
+    r"""Deprecated: Use FileToolkit instead.
+
+    This class is maintained for backward compatibility only.
+    Please use FileToolkit for new code.
+    """
+
+    def __init__(self, *args, **kwargs):
+        import warnings
+
+        warnings.warn(
+            "FileWriteToolkit is deprecated and will be removed in a "
+            "future version. Please use FileToolkit instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        super().__init__(*args, **kwargs)

camel/toolkits/function_tool.py

@@ -156,7 +156,12 @@ def get_openai_tool_schema(func: Callable) -> Dict[str, Any]:
         if (name := param.arg_name) in parameters_dict["properties"] and (
             description := param.description
         ):
-            parameters_dict["properties"][name]["description"] = description
+            # OpenAI does not allow descriptions on properties that use $ref.
+            # To avoid schema errors, we only add the description if "$ref" is
+            # not present.
+            prop = parameters_dict["properties"][name]
+            if "$ref" not in prop:
+                prop["description"] = description
 
     short_description = docstring.short_description or ""
     long_description = docstring.long_description or ""

camel/toolkits/github_toolkit.py

@@ -14,6 +14,7 @@
 
 import logging
 import os
+import warnings
 from typing import Dict, List, Literal, Optional, Union
 
 from camel.toolkits import FunctionTool
@@ -80,7 +81,7 @@ class GithubToolkit(BaseToolkit):
             )
         return GITHUB_ACCESS_TOKEN
 
-    def create_pull_request(
+    def github_create_pull_request(
         self,
         repo_name: str,
         file_path: str,
@@ -150,7 +151,7 @@ class GithubToolkit(BaseToolkit):
         else:
             raise ValueError("PRs with multiple files aren't supported yet.")
 
-    def get_issue_list(
+    def github_get_issue_list(
         self, repo_name: str, state: Literal["open", "closed", "all"] = "all"
     ) -> List[Dict[str, object]]:
         r"""Retrieves all issues from the GitHub repository.
@@ -177,7 +178,9 @@ class GithubToolkit(BaseToolkit):
 
         return issues_info
 
-    def get_issue_content(self, repo_name: str, issue_number: int) -> str:
+    def github_get_issue_content(
+        self, repo_name: str, issue_number: int
+    ) -> str:
         r"""Retrieves the content of a specific issue by its number.
 
         Args:
@@ -194,7 +197,7 @@ class GithubToolkit(BaseToolkit):
         except Exception as e:
             return f"can't get Issue number {issue_number}: {e!s}"
 
-    def get_pull_request_list(
+    def github_get_pull_request_list(
         self, repo_name: str, state: Literal["open", "closed", "all"] = "all"
     ) -> List[Dict[str, object]]:
         r"""Retrieves all pull requests from the GitHub repository.
@@ -221,7 +224,7 @@ class GithubToolkit(BaseToolkit):
 
         return pull_requests_info
 
-    def get_pull_request_code(
+    def github_get_pull_request_code(
         self, repo_name: str, pr_number: int
     ) -> List[Dict[str, str]]:
         r"""Retrieves the code changes of a specific pull request.
@@ -253,7 +256,7 @@ class GithubToolkit(BaseToolkit):
 
         return files_changed
 
-    def get_pull_request_comments(
+    def github_get_pull_request_comments(
         self, repo_name: str, pr_number: int
     ) -> List[Dict[str, str]]:
         r"""Retrieves the comments from a specific pull request.
@@ -278,7 +281,9 @@ class GithubToolkit(BaseToolkit):
 
         return comments
 
-    def get_all_file_paths(self, repo_name: str, path: str = "") -> List[str]:
+    def github_get_all_file_paths(
+        self, repo_name: str, path: str = ""
+    ) -> List[str]:
         r"""Recursively retrieves all file paths in the GitHub repository.
 
         Args:
@@ -308,13 +313,15 @@ class GithubToolkit(BaseToolkit):
             for content in contents:
                 if content.type == "dir":
                     # If it's a directory, recursively retrieve its file paths
-                    files.extend(self.get_all_file_paths(content.path))
+                    files.extend(self.github_get_all_file_paths(content.path))
                 else:
                     # If it's a file, add its path to the list
                     files.append(content.path)
         return files
 
-    def retrieve_file_content(self, repo_name: str, file_path: str) -> str:
+    def github_retrieve_file_content(
+        self, repo_name: str, file_path: str
+    ) -> str:
         r"""Retrieves the content of a file from the GitHub repository.
 
         Args:
@@ -343,12 +350,92 @@ class GithubToolkit(BaseToolkit):
                 the functions in the toolkit.
         """
         return [
-            FunctionTool(self.create_pull_request),
-            FunctionTool(self.get_issue_list),
-            FunctionTool(self.get_issue_content),
-            FunctionTool(self.get_pull_request_list),
-            FunctionTool(self.get_pull_request_code),
-            FunctionTool(self.get_pull_request_comments),
-            FunctionTool(self.get_all_file_paths),
-            FunctionTool(self.retrieve_file_content),
+            FunctionTool(self.github_create_pull_request),
+            FunctionTool(self.github_get_issue_list),
+            FunctionTool(self.github_get_issue_content),
+            FunctionTool(self.github_get_pull_request_list),
+            FunctionTool(self.github_get_pull_request_code),
+            FunctionTool(self.github_get_pull_request_comments),
+            FunctionTool(self.github_get_all_file_paths),
+            FunctionTool(self.github_retrieve_file_content),
         ]
+
+    # Deprecated method aliases for backward compatibility
+    def create_pull_request(self, *args, **kwargs):
+        r"""Deprecated: Use github_create_pull_request instead."""
+        warnings.warn(
+            "create_pull_request is deprecated. Use "
+            "github_create_pull_request instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.github_create_pull_request(*args, **kwargs)
+
+    def get_issue_list(self, *args, **kwargs):
+        r"""Deprecated: Use github_get_issue_list instead."""
+        warnings.warn(
+            "get_issue_list is deprecated. Use github_get_issue_list instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.github_get_issue_list(*args, **kwargs)
+
+    def get_issue_content(self, *args, **kwargs):
+        r"""Deprecated: Use github_get_issue_content instead."""
+        warnings.warn(
+            "get_issue_content is deprecated. Use "
+            "github_get_issue_content instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.github_get_issue_content(*args, **kwargs)
+
+    def get_pull_request_list(self, *args, **kwargs):
+        r"""Deprecated: Use github_get_pull_request_list instead."""
+        warnings.warn(
+            "get_pull_request_list is deprecated. "
+            "Use github_get_pull_request_list instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.github_get_pull_request_list(*args, **kwargs)
+
+    def get_pull_request_code(self, *args, **kwargs):
+        r"""Deprecated: Use github_get_pull_request_code instead."""
+        warnings.warn(
+            "get_pull_request_code is deprecated. Use "
+            "github_get_pull_request_code instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.github_get_pull_request_code(*args, **kwargs)
+
+    def get_pull_request_comments(self, *args, **kwargs):
+        r"""Deprecated: Use github_get_pull_request_comments instead."""
+        warnings.warn(
+            "get_pull_request_comments is deprecated. "
+            "Use github_get_pull_request_comments instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.github_get_pull_request_comments(*args, **kwargs)
+
+    def get_all_file_paths(self, *args, **kwargs):
+        r"""Deprecated: Use github_get_all_file_paths instead."""
+        warnings.warn(
+            "get_all_file_paths is deprecated. Use "
+            "github_get_all_file_paths instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.github_get_all_file_paths(*args, **kwargs)
+
+    def retrieve_file_content(self, *args, **kwargs):
+        r"""Deprecated: Use github_retrieve_file_content instead."""
+        warnings.warn(
+            "retrieve_file_content is deprecated. "
+            "Use github_retrieve_file_content instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.github_retrieve_file_content(*args, **kwargs)

camel/toolkits/google_drive_mcp_toolkit.py

@@ -12,14 +12,12 @@
 # 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 typing import Optional
 
 from .mcp_toolkit import MCPToolkit
 
 
-class GoogleDriveMCPToolkit(BaseToolkit):
+class GoogleDriveMCPToolkit(MCPToolkit):
     r"""GoogleDriveMCPToolkit provides an interface for interacting with
     Google Drive using the Google Drive MCP server.
 
@@ -41,33 +39,16 @@ class GoogleDriveMCPToolkit(BaseToolkit):
             credentials_path (Optional[str]): Path to the Google Drive
                 credentials file. (default: :obj:`None`)
         """
-        super().__init__(timeout=timeout)
 
-        self._mcp_toolkit = MCPToolkit(
-            config_dict={
-                "mcpServers": {
-                    "gdrive": {
-                        "command": "npx",
-                        "args": ["-y", "@modelcontextprotocol/server-gdrive"],
-                        "env": {"GDRIVE_CREDENTIALS_PATH": credentials_path},
-                    }
+        config_dict = {
+            "mcpServers": {
+                "gdrive": {
+                    "command": "npx",
+                    "args": ["-y", "@modelcontextprotocol/server-gdrive"],
+                    "env": {"GDRIVE_CREDENTIALS_PATH": credentials_path},
                 }
-            },
-            timeout=timeout,
-        )
-
-    async def connect(self):
-        r"""Explicitly connect to the Google Drive MCP server."""
-        await self._mcp_toolkit.connect()
-
-    async def disconnect(self):
-        r"""Explicitly disconnect from the Google Drive MCP server."""
-        await self._mcp_toolkit.disconnect()
+            }
+        }
 
-    def get_tools(self) -> List[FunctionTool]:
-        r"""Returns a list of tools provided by the GoogleDriveMCPToolkit.
-
-        Returns:
-            List[FunctionTool]: List of available tools.
-        """
-        return self._mcp_toolkit.get_tools()
+        # Initialize parent MCPToolkit with Playwright configuration
+        super().__init__(config_dict=config_dict, timeout=timeout)

camel/toolkits/hybrid_browser_toolkit/config_loader.py

@@ -43,6 +43,10 @@ class BrowserConfig:
     # CDP connection configuration
     connect_over_cdp: bool = False
     cdp_url: Optional[str] = None
+    cdp_keep_current_page: bool = False
+
+    # Full visual mode configuration
+    full_visual_mode: bool = False
 
 
 @dataclass
@@ -51,6 +55,7 @@ class ToolkitConfig:
 
     cache_dir: str = "tmp/"
     browser_log_to_file: bool = False
+    log_dir: Optional[str] = None
     session_id: Optional[str] = None
     enabled_tools: Optional[list] = None
 
@@ -106,6 +111,8 @@ class ConfigLoader:
                 browser_kwargs["connect_over_cdp"] = value
             elif key == "cdpUrl":
                 browser_kwargs["cdp_url"] = value
+            elif key == "cdpKeepCurrentPage":
+                browser_kwargs["cdp_keep_current_page"] = value
             elif key == "consoleLogLimit":
                 browser_kwargs["console_log_limit"] = value
             elif key == "cacheDir":
@@ -116,6 +123,8 @@ class ConfigLoader:
                 toolkit_kwargs["session_id"] = value
             elif key == "enabledTools":
                 toolkit_kwargs["enabled_tools"] = value
+            elif key == "fullVisualMode":
+                browser_kwargs["full_visual_mode"] = value
 
         browser_config = BrowserConfig(**browser_kwargs)
         toolkit_config = ToolkitConfig(**toolkit_kwargs)
@@ -142,10 +151,13 @@ class ConfigLoader:
             "screenshotTimeout": self.browser_config.screenshot_timeout,
             "pageStabilityTimeout": self.browser_config.page_stability_timeout,
             "browser_log_to_file": self.toolkit_config.browser_log_to_file,
+            "log_dir": self.toolkit_config.log_dir,
             "session_id": self.toolkit_config.session_id,
             "viewport_limit": self.browser_config.viewport_limit,
             "connectOverCdp": self.browser_config.connect_over_cdp,
             "cdpUrl": self.browser_config.cdp_url,
+            "cdpKeepCurrentPage": self.browser_config.cdp_keep_current_page,
+            "fullVisualMode": self.browser_config.full_visual_mode,
         }
 
     def get_timeout_config(self) -> Dict[str, Optional[int]]: