camel-ai 0.2.67__py3-none-any.whl → 0.2.80a2__py3-none-any.whl

camel/toolkits/openbb_toolkit.py

@@ -17,7 +17,11 @@ from typing import List, Literal, Optional
 
 from camel.toolkits.base import BaseToolkit
 from camel.toolkits.function_tool import FunctionTool
-from camel.utils import MCPServer, api_keys_required, dependencies_required
+from camel.utils import (
+    MCPServer,
+    api_keys_required,
+    dependencies_required,
+)
 
 
 @MCPServer()

camel/toolkits/origene_mcp_toolkit.py

@@ -0,0 +1,56 @@
+# ========= 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, Optional
+
+from .mcp_toolkit import MCPToolkit
+
+
+class OrigeneToolkit(MCPToolkit):
+    r"""OrigeneToolkit provides an interface for interacting with
+    Origene MCP server.
+
+    This toolkit can be used as an async context manager for automatic
+    connection management:
+
+        async with OrigeneToolkit(config_dict=config) as toolkit:
+            tools = toolkit.get_tools()
+            # Toolkit is automatically disconnected when exiting
+
+    Attributes:
+        config_dict (Dict): Configuration dictionary for MCP servers.
+        timeout (Optional[float]): Connection timeout in seconds.
+            (default: :obj:`None`)
+    """
+
+    def __init__(
+        self,
+        config_dict: Optional[Dict] = None,
+        timeout: Optional[float] = None,
+    ) -> None:
+        r"""Initializes the OrigeneToolkit.
+
+        Args:
+            config_dict (Optional[Dict]): Configuration dictionary for MCP
+                servers. If None, raises ValueError as configuration is
+                required. (default: :obj:`None`)
+            timeout (Optional[float]): Connection timeout in seconds.
+                (default: :obj:`None`)
+        """
+        # Validate that config_dict is provided
+        if config_dict is None:
+            raise ValueError("config_dict must be provided")
+
+        # Initialize parent MCPToolkit with provided configuration
+        super().__init__(config_dict=config_dict, timeout=timeout)

camel/toolkits/playwright_mcp_toolkit.py

@@ -14,12 +14,10 @@
 
 from typing import List, Optional
 
-from camel.toolkits import BaseToolkit, FunctionTool
-
 from .mcp_toolkit import MCPToolkit
 
 
-class PlaywrightMCPToolkit(BaseToolkit):
+class PlaywrightMCPToolkit(MCPToolkit):
     r"""PlaywrightMCPToolkit provides an interface for interacting with web
     browsers using the Playwright automation library through the Model Context
     Protocol (MCP).
@@ -51,33 +49,16 @@ class PlaywrightMCPToolkit(BaseToolkit):
                 `["--cdp-endpoint=http://localhost:9222"]`.
                 (default: :obj:`None`)
         """
-        super().__init__(timeout=timeout)
-
-        self._mcp_toolkit = MCPToolkit(
-            config_dict={
-                "mcpServers": {
-                    "playwright": {
-                        "command": "npx",
-                        "args": ["@playwright/mcp@latest"]
-                        + (additional_args or []),
-                    }
+        # Create config for Playwright MCP server
+        config_dict = {
+            "mcpServers": {
+                "playwright": {
+                    "command": "npx",
+                    "args": ["@playwright/mcp@latest"]
+                    + (additional_args or []),
                 }
-            },
-            timeout=timeout,
-        )
-
-    async def connect(self):
-        r"""Explicitly connect to the Playwright MCP server."""
-        await self._mcp_toolkit.connect()
+            }
+        }
 
-    async def disconnect(self):
-        r"""Explicitly disconnect from the Playwright MCP server."""
-        await self._mcp_toolkit.disconnect()
-
-    def get_tools(self) -> List[FunctionTool]:
-        r"""Returns a list of tools provided by the PlaywrightMCPToolkit.
-
-        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/pptx_toolkit.py

@@ -53,22 +53,35 @@ class PPTXToolkit(BaseToolkit):
 
     def __init__(
         self,
-        output_dir: str = "./",
+        working_directory: Optional[str] = None,
         timeout: Optional[float] = None,
     ) -> None:
         r"""Initialize the PPTXToolkit.
 
         Args:
-            output_dir (str): The default directory for output files.
-                Defaults to the current working directory.
+            working_directory (str, optional): The default directory for
+                output files. If not provided, it will be determined by the
+                `CAMEL_WORKDIR` environment variable (if set). If the
+                environment variable is not set, it defaults to
+                `camel_working_dir`.
             timeout (Optional[float]): The timeout for the toolkit.
-                (default: :obj: `None`)
+                (default: :obj:`None`)
         """
         super().__init__(timeout=timeout)
-        self.output_dir = Path(output_dir).resolve()
-        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+        if working_directory:
+            self.working_directory = Path(working_directory).resolve()
+        else:
+            camel_workdir = os.environ.get("CAMEL_WORKDIR")
+            if camel_workdir:
+                self.working_directory = Path(camel_workdir).resolve()
+            else:
+                self.working_directory = Path("./camel_working_dir").resolve()
+
+        self.working_directory.mkdir(parents=True, exist_ok=True)
         logger.info(
-            f"PPTXToolkit initialized with output directory: {self.output_dir}"
+            f"PPTXToolkit initialized with output directory: "
+            f"{self.working_directory}"
         )
 
     def _resolve_filepath(self, file_path: str) -> Path:
@@ -87,7 +100,7 @@ class PPTXToolkit(BaseToolkit):
         """
         path_obj = Path(file_path)
         if not path_obj.is_absolute():
-            path_obj = self.output_dir / path_obj
+            path_obj = self.working_directory / path_obj
 
         sanitized_filename = self._sanitize_filename(path_obj.name)
         path_obj = path_obj.parent / sanitized_filename
@@ -120,7 +133,7 @@ class PPTXToolkit(BaseToolkit):
             frame_paragraph: The paragraph to format.
             text (str): The text to format.
             set_color_to_white (bool): Whether to set the color to white.
-                (default: :obj: `False`)
+                (default: :obj:`False`)
         """
         from pptx.dml.color import RGBColor
 
@@ -170,7 +183,7 @@ class PPTXToolkit(BaseToolkit):
             flat_items_list (List[Tuple[str, int]]): The list of items to be
                 displayed.
             set_color_to_white (bool): Whether to set the font color to white.
-                (default: :obj: `False`)
+                (default: :obj:`False`)
         """
         if not flat_items_list:
             logger.warning("Empty bullet point list provided")
@@ -365,10 +378,10 @@ class PPTXToolkit(BaseToolkit):
                     * Table slides: {"heading": str, "table": {"headers": list
                     of str, "rows": list of list of str}}
             filename (str): The name or path of the file. If a relative path is
-                supplied, it is resolved to self.output_dir.
+                supplied, it is resolved to self.working_directory.
             template (Optional[str]): The path to the template PPTX file.
                 Initializes a presentation from a given template file Or PPTX
-                file. (default: :obj: `None`)
+                file. (default: :obj:`None`)
 
         Returns:
             str: A success message indicating the file was created.

camel/toolkits/resend_toolkit.py

@@ -0,0 +1,168 @@
+# ========= 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, cast
+
+from camel.toolkits.base import BaseToolkit
+from camel.toolkits.function_tool import FunctionTool
+from camel.utils import MCPServer, api_keys_required
+
+
+@MCPServer()
+class ResendToolkit(BaseToolkit):
+    r"""A toolkit for sending emails using the Resend API.
+
+    This toolkit provides functionality to send emails using Resend's
+    Python SDK.It supports sending both HTML and plain text emails,
+    with options for multiple recipients, CC, BCC, reply-to
+    addresses, and custom headers.
+
+    Notes:
+        To use this toolkit, you need to set the following environment
+        variable:
+        - RESEND_API_KEY: Your Resend API key. You can get one from
+          https://resend.com/api-keys
+
+    Example:
+        .. code-block:: python
+
+            from camel.toolkits import ResendToolkit
+
+            # Initialize the toolkit
+            toolkit = ResendToolkit()
+
+            # Get tools
+            tools = toolkit.get_tools()
+    """
+
+    @api_keys_required([(None, "RESEND_API_KEY")])
+    def send_email(
+        self,
+        to: List[str],
+        subject: str,
+        from_email: str,
+        html: Optional[str] = None,
+        text: Optional[str] = None,
+        cc: Optional[List[str]] = None,
+        bcc: Optional[List[str]] = None,
+        reply_to: Optional[str] = None,
+        tags: Optional[List[Dict[str, str]]] = None,
+        headers: Optional[Dict[str, str]] = None,
+    ) -> str:
+        r"""Send an email using the Resend API.
+
+        Args:
+            to (List[str]): List of recipient email addresses.
+            subject (str): The email subject line.
+            from_email (str): The sender email address. Must be from a verified
+                domain.
+            html (Optional[str]): The HTML content of the email. Either html or
+                text must be provided. (default: :obj:`None`)
+            text (Optional[str]): The plain text content of the email. Either
+                html or text must be provided. (default: :obj:`None`)
+            cc (Optional[List[str]]): List of CC recipient email addresses.
+                (default: :obj:`None`)
+            bcc (Optional[List[str]]): List of BCC recipient email addresses.
+                (default: :obj:`None`)
+            reply_to (Optional[str]): The reply-to email address.
+                (default: :obj:`None`)
+            tags (Optional[List[Dict[str, str]]]): List of tags to attach to
+                the email. Each tag should be a dict with 'name' and
+                'value' keys. (default: :obj:`None`)
+            headers (Optional[Dict[str, str]]): Custom headers to include in
+                the email.(default: :obj:`None`)
+
+        Returns:
+            str: A success message with the email ID if sent successfully,
+                or an error message if the send failed.
+
+        Raises:
+            ValueError: If neither html nor text content is provided.
+
+        Example:
+            .. code-block:: python
+
+                toolkit = ResendToolkit()
+                result = toolkit.send_email(
+                    to=["recipient@example.com"],
+                    subject="Hello World",
+                    from_email="sender@yourdomain.com",
+                    html="<h1>Hello, World!</h1>",
+                    text="Hello, World!"
+                )
+        """
+        import os
+
+        if not html and not text:
+            raise ValueError(
+                "Either 'html' or 'text' content must be provided"
+            )
+
+        try:
+            import resend
+        except ImportError:
+            raise ImportError(
+                "Please install the resend package first. "
+                "You can install it by running `pip install resend`."
+            )
+
+        # Set the API key
+        resend.api_key = os.getenv("RESEND_API_KEY")
+
+        # Prepare email parameters
+        params: resend.Emails.SendParams = {
+            "from": from_email,
+            "to": to,
+            "subject": subject,
+        }
+
+        # Add content
+        if html:
+            params["html"] = html
+        if text:
+            params["text"] = text
+
+        # Add optional parameters
+        if cc:
+            params["cc"] = cc
+        if bcc:
+            params["bcc"] = bcc
+        if reply_to:
+            params["reply_to"] = reply_to
+        if tags:
+            params["tags"] = cast('list[resend.emails._tag.Tag]', tags)
+        if headers:
+            params["headers"] = headers
+
+        try:
+            # Send the email
+            email = resend.Emails.send(params)
+            return (
+                f"Email sent successfully. "
+                f"Email ID: {email.get('id', 'Unknown')}"
+            )
+        except Exception as e:
+            return f"Failed to send email: {e!s}"
+
+    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.send_email),
+        ]

camel/toolkits/screenshot_toolkit.py

@@ -0,0 +1,213 @@
+# ========= 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 os
+from pathlib import Path
+from typing import List, Optional
+
+from PIL import Image
+
+from camel.logger import get_logger
+from camel.messages import BaseMessage
+from camel.toolkits import BaseToolkit, FunctionTool
+from camel.toolkits.base import RegisteredAgentToolkit
+from camel.utils import dependencies_required
+
+logger = get_logger(__name__)
+
+
+class ScreenshotToolkit(BaseToolkit, RegisteredAgentToolkit):
+    r"""A toolkit for taking screenshots."""
+
+    @dependencies_required('PIL')
+    def __init__(
+        self,
+        working_directory: Optional[str] = None,
+        timeout: Optional[float] = None,
+    ):
+        r"""Initializes the ScreenshotToolkit.
+
+        Args:
+            working_directory (str, optional): The directory path where notes
+                will be stored. If not provided, it will be determined by the
+                `CAMEL_WORKDIR` environment variable (if set). If the
+                environment variable is not set, it defaults to
+                `camel_working_dir`.
+            timeout (Optional[float]): Timeout for API requests in seconds.
+                (default: :obj:`None`)
+        """
+        from PIL import ImageGrab
+
+        super().__init__(timeout=timeout)
+        RegisteredAgentToolkit.__init__(self)
+
+        camel_workdir = os.environ.get("CAMEL_WORKDIR")
+        if working_directory:
+            path = Path(working_directory)
+        elif camel_workdir:
+            path = Path(camel_workdir)
+        else:
+            path = Path("camel_working_dir")
+
+        self.ImageGrab = ImageGrab
+        self.screenshots_dir = path
+        self.screenshots_dir.mkdir(parents=True, exist_ok=True)
+
+    def read_image(
+        self,
+        image_path: str,
+        instruction: str = "",
+    ) -> str:
+        r"""Analyzes an image from a local file path.
+
+        This function enables you to "see" and interpret an image from a
+        file. It's useful for tasks where you need to understand visual
+        information, such as reading a screenshot of a webpage or a diagram.
+
+        Args:
+            image_path (str): The local file path to the image.
+                For example: 'screenshots/login_page.png'.
+            instruction (str, optional): Specific instructions for what to look
+                for or what to do with the image. For example: "What is the
+                main headline on this page?" or "Find the 'Submit' button.".
+
+        Returns:
+            str: The response after analyzing the image, which could be a
+                 description, an answer, or a confirmation of an action.
+        """
+        if self.agent is None:
+            logger.error(
+                "Cannot record screenshot in memory: No agent registered. "
+                "Please pass this toolkit to ChatAgent via "
+                "toolkits_to_register_agent parameter."
+            )
+            return (
+                "Error: No agent registered. Please pass this toolkit to "
+                "ChatAgent via toolkits_to_register_agent parameter."
+            )
+
+        try:
+            image_path = str(Path(image_path).absolute())
+
+            # Check if file exists before trying to open
+            if not os.path.exists(image_path):
+                error_msg = f"Screenshot file not found: {image_path}"
+                logger.error(error_msg)
+                return f"Error: {error_msg}"
+
+            # Load the image from the path
+            img = Image.open(image_path)
+
+            # Create a message with the screenshot image
+            message = BaseMessage.make_user_message(
+                role_name="User",
+                content=instruction,
+                image_list=[img],
+            )
+
+            # Record the message in agent's memory
+            response = self.agent.step(message)
+            return response.msgs[0].content
+
+        except Exception as e:
+            logger.error(f"Error reading screenshot: {e}")
+            return f"Error reading screenshot: {e}"
+
+    def take_screenshot_and_read_image(
+        self,
+        filename: str,
+        save_to_file: bool = True,
+        read_image: bool = True,
+        instruction: Optional[str] = None,
+    ) -> str:
+        r"""Captures a screenshot of the entire screen.
+
+        This function can save the screenshot to a file and optionally analyze
+        it. It's useful for capturing the current state of the UI for
+        documentation, analysis, or to guide subsequent actions.
+
+        Args:
+            filename (str): The name for the screenshot file (e.g.,
+                "homepage.png"). The file is saved in a `screenshots`
+                subdirectory within the working directory. Must end with
+                `.png`. (default: :obj:`None`)
+            save_to_file (bool, optional): If `True`, saves the screenshot to
+                a file. (default: :obj:`True`)
+            read_image (bool, optional): If `True`, the agent will analyze
+                the screenshot. `save_to_file` must also be `True`.
+                (default: :obj:`True`)
+            instruction (Optional[str], optional): A specific question or
+                command for the agent regarding the screenshot, used only if
+                `read_image` is `True`. For example: "Confirm that the
+                user is logged in.".
+
+        Returns:
+            str: A confirmation message indicating success or failure,
+                 including the file path if saved, and the agent's response
+                 if `read_image` is `True`.
+        """
+        try:
+            # Take screenshot of entire screen
+            screenshot = self.ImageGrab.grab()
+
+            # Save to file if requested
+            file_path = None
+            if save_to_file:
+                # Create directory if it doesn't exist
+                os.makedirs(self.screenshots_dir, exist_ok=True)
+
+                # Create unique filename if file already exists
+                base_path = os.path.join(self.screenshots_dir, filename)
+                file_path = base_path
+                counter = 1
+                while os.path.exists(file_path):
+                    name, ext = os.path.splitext(filename)
+                    unique_filename = f"{name}_{counter}{ext}"
+                    file_path = os.path.join(
+                        self.screenshots_dir, unique_filename
+                    )
+                    counter += 1
+
+                screenshot.save(file_path)
+                logger.info(f"Screenshot saved to {file_path}")
+
+            # Create result text
+            result_text = "Screenshot captured successfully"
+            if file_path:
+                result_text += f" and saved to {file_path}"
+
+            # Record in agent memory if requested
+            if read_image and file_path is not None:
+                inst = instruction if instruction is not None else ""
+                response = self.read_image(
+                    str(Path(file_path).absolute()), inst
+                )
+                result_text += f". Agent response: {response}"
+
+            return result_text
+
+        except Exception as e:
+            logger.error(f"Error taking screenshot: {e}")
+            return f"Error taking screenshot: {e}"
+
+    def get_tools(self) -> List[FunctionTool]:
+        r"""Returns a list of FunctionTool objects for screenshot operations.
+
+        Returns:
+            List[FunctionTool]: List of screenshot functions.
+        """
+        return [
+            FunctionTool(self.take_screenshot_and_read_image),
+            FunctionTool(self.read_image),
+        ]