camel-ai 0.2.43__py3-none-any.whl → 0.2.45__py3-none-any.whl

camel/runtime/ubuntu_docker_runtime.py

@@ -0,0 +1,340 @@
+# ========= 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 logging
+import sys
+import time
+from pathlib import Path
+from typing import Callable, List, Optional, Union
+
+from camel.runtime.docker_runtime import DockerRuntime
+from camel.toolkits import FunctionTool
+
+logger = logging.getLogger(__name__)
+
+
+class UbuntuDockerRuntime(DockerRuntime):
+    r"""A specialized Docker runtime for Ubuntu-based environments.
+
+    This runtime includes specific configurations and setup for Ubuntu
+    containers, including proper Python path handling and environment setup.
+    It provides methods for executing Python files, managing the container
+    lifecycle, and handling file operations within the Ubuntu container.
+
+    Attributes:
+        python_path (str): Path to the Python interpreter in the container
+        docker_config (dict): Configuration dict for Docker container setup
+    """
+
+    def __init__(
+        self,
+        image: str,
+        port: int = 0,
+        remove: bool = True,
+        python_path: str = "/usr/bin/python3",
+        **kwargs,
+    ):
+        r"""Initialize the Ubuntu Docker Runtime.
+
+        Args:
+            image (str): Docker image name to use
+            port (int, optional): Port to expose. Defaults to 0 (random port)
+            remove (bool, optional): Whether to remove container after use.
+                                   Defaults to True
+            python_path (str, optional): Path to Python interpreter.
+                                       Defaults to "/usr/bin/python3"
+            **kwargs: Additional arguments passed to DockerRuntime
+        """
+        super().__init__(image=image, port=port, remove=remove, **kwargs)
+
+        self.python_path = python_path
+        logger.info(
+            f"Initializing UbuntuDockerRuntime with python_path: {python_path}"
+        )
+
+        # Set default environment variables for Ubuntu
+        self.docker_config.setdefault("environment", {})
+        self.docker_config["environment"].update(
+            {
+                "PYTHON_PATH": python_path,
+                "PYTHON_EXECUTABLE": python_path,
+                "PATH": "/usr/local/bin:/usr/bin:/bin",
+                "PYTHONUNBUFFERED": "1",
+            }
+        )
+        logger.info(
+            f"Environment variables set: {self.docker_config['environment']}"
+        )
+
+        # Add default working directory
+        self.docker_config.setdefault("working_dir", "/app")
+
+        # Setup default volume mounts
+        self._setup_default_mounts()
+
+    def add(
+        self,
+        funcs: Union[FunctionTool, List[FunctionTool]],
+        entrypoint: str,
+        redirect_stdout: bool = False,
+        arguments: Optional[dict] = None,
+    ) -> "UbuntuDockerRuntime":
+        r"""Add functions to the runtime with Ubuntu-specific modifications.
+
+        Args:
+            funcs: Function(s) to add to the runtime
+            entrypoint: Entry point for function execution
+            redirect_stdout: Whether to redirect stdout
+            arguments: Optional arguments for function execution
+
+        Returns:
+            Self for method chaining
+        """
+        if not isinstance(funcs, list):
+            funcs = [funcs]
+
+        # Modify the code execution command to use python3
+        for func in funcs:
+            logger.info(f"Processing function: {func.get_function_name()}")
+            if hasattr(func, 'command'):
+                logger.info(f"Original command: {func.command}")
+                if isinstance(func.command, list):
+                    if 'python' in func.command:
+                        idx = func.command.index('python')
+                        func.command[idx] = self.python_path
+                        logger.info(f"Modified command: {func.command}")
+            else:
+                logger.info(
+                    f"No command attribute found for function "
+                    f"{func.get_function_name()}"
+                )
+
+        super().add(funcs, entrypoint, redirect_stdout, arguments)
+        return self
+
+    def _setup_default_mounts(self):
+        r"""Setup default volume mounts for the container.
+
+        This method can be extended to add Ubuntu-specific volume mounts.
+        """
+        pass
+
+    def build(self, time_out: int = 15) -> "UbuntuDockerRuntime":
+        r"""Build and initialize the Ubuntu container with proper setup.
+
+        Args:
+            time_out (int): Timeout in seconds for build operation
+
+        Returns:
+            Self for method chaining
+        """
+        logger.info("Starting container build...")
+
+        super().build(time_out=time_out)
+
+        if self.container:
+            logger.info("Container built successfully, verifying setup...")
+
+            # Verify Python installation
+            exit_code, output = self.container.exec_run(
+                [self.python_path, "--version"]
+            )
+            logger.info(f"Python version check result: {output.decode()}")
+            if exit_code != 0:
+                logger.error(
+                    f"Python version check failed with exit code {exit_code}"
+                )
+                raise RuntimeError(
+                    f"Python installation verification "
+                    f"failed: {output.decode()}"
+                )
+
+            # Install required packages
+            logger.info("Installing required packages...")
+            exit_code, output = self.container.exec_run("apt-get update")
+            if exit_code != 0:
+                logger.error(
+                    f"apt-get update failed with "
+                    f"exit code {exit_code}: {output.decode()}"
+                )
+                raise RuntimeError(
+                    f"Failed to update package lists: {output.decode()}"
+                )
+
+            exit_code, output = self.container.exec_run(
+                "apt-get install -y curl"
+            )
+            if exit_code != 0:
+                logger.error(
+                    f"apt-get install curl failed with "
+                    f"exit code {exit_code}: {output.decode()}"
+                )
+                raise RuntimeError(
+                    f"Failed to install curl: {output.decode()}"
+                )
+
+            # Start API server with explicit Python path
+            logger.info("Starting API server...")
+            exec_result = self.container.exec_run(
+                [self.python_path, "/home/api.py"],
+                detach=True,
+                environment={
+                    "PYTHONPATH": str(
+                        Path(self.python_path).parent
+                        / "lib/python3.10/site-packages"
+                    ),
+                    "PYTHON_EXECUTABLE": self.python_path,
+                },
+            )
+            logger.info("API server start result: %s", exec_result)
+
+            # Wait for API server to start
+            start_time = time.time()
+            while time.time() - start_time < 10:
+                try:
+                    exit_code, curl_result = self.container.exec_run(
+                        "curl -s -o /dev/null -w '%{http_code}' http://localhost:8000/docs"
+                    )
+                    status_code = curl_result.decode().strip()
+                    if exit_code == 0 and status_code.startswith('2'):
+                        logger.info(
+                            f"API server is running "
+                            f"(status code: {status_code})"
+                        )
+                        break
+                    else:
+                        logger.debug(
+                            f"API server not ready yet (status: {status_code})"
+                        )
+                except Exception as e:
+                    logger.debug("Waiting for API server... %s", e)
+                time.sleep(0.5)
+            else:
+                logger.warning("API server may not be running properly")
+
+        return self
+
+    def exec_python_file(
+        self,
+        local_file_path: str,
+        container_path: Optional[str] = None,
+        args: Optional[List[str]] = None,
+        env: Optional[dict] = None,
+        callback: Optional[Callable[[str], None]] = None,
+    ) -> None:
+        r"""Execute a Python file inside the Docker container.
+
+        Args:
+            local_file_path: Path to the Python file on the local filesystem
+            container_path: Path where the file should be copied in the
+            container If None, the file will be copied to /tmp/
+            args: List of command-line arguments to pass to the Python script
+            env: Additional environment variables to set for the execution
+            callback: Optional function to process each line of output
+                     If None, output is printed to stdout
+
+        Raises:
+            RuntimeError: If container is not running
+            FileNotFoundError: If Python file is not found
+        """
+        if not self.container:
+            raise RuntimeError("Container is not running. Call build() first.")
+
+        local_path = Path(local_file_path)
+        if not local_path.exists():
+            raise FileNotFoundError(f"Python file {local_file_path} not found")
+
+        # Determine where to put the file in the container
+        if container_path is None:
+            container_path = f"/tmp/{local_path.name}"
+
+        logger.info(
+            f"Copying {local_file_path} to container at {container_path}"
+        )
+
+        # Copy the file to the container
+        self.container.put_archive(
+            path=str(Path(container_path).parent),
+            data=self._create_archive_from_file(local_path),
+        )
+
+        # Prepare command
+        cmd = [self.python_path, container_path]
+        if args:
+            cmd.extend(args)
+
+        # Prepare environment
+        execution_env = {
+            "PYTHONPATH": "/usr/local/lib/python3.10/site-packages",
+            "PYTHON_EXECUTABLE": self.python_path,
+        }
+        execution_env["PYTHONPATH"] = str(
+            Path(self.python_path).parent / "lib/python3.10/site-packages"
+        )
+        if env:
+            execution_env.update(env)
+
+        logger.info(f"Executing Python file with command: {cmd}")
+
+        # Always use streaming output
+        exec_result = self.container.exec_run(
+            cmd,
+            environment=execution_env,
+            stream=True,
+            demux=True,  # Separate stdout and stderr
+        )
+
+        # Handle output streams
+        try:
+            for stdout, stderr in exec_result[1]:
+                if stdout:
+                    output = stdout.decode('utf-8')
+                    if callback:
+                        callback(output)
+                    else:
+                        print(output, end='')
+
+                if stderr:
+                    error = stderr.decode('utf-8')
+                    if callback:
+                        callback(f"ERROR: {error}")
+                    else:
+                        print(f"ERROR: {error}", end='', file=sys.stderr)
+        except KeyboardInterrupt:
+            logger.info("Execution interrupted by user")
+            # Could add logic to stop container processes here
+        except Exception as e:
+            logger.error(f"Error during execution: {e}")
+            raise
+
+    def _create_archive_from_file(self, file_path: Union[str, Path]) -> bytes:
+        r"""Create a tar archive from a single file for docker.put_archive().
+
+        Args:
+            file_path: Path to the file to archive
+
+        Returns:
+            bytes: The tar archive as bytes
+        """
+        import io
+        import tarfile
+
+        file_path = Path(file_path)
+        tar_stream = io.BytesIO()
+
+        with tarfile.open(fileobj=tar_stream, mode='w') as tar:
+            tar.add(file_path, arcname=file_path.name)
+
+        tar_stream.seek(0)
+        return tar_stream.read()

camel/toolkits/audio_analysis_toolkit.py

@@ -83,29 +83,33 @@ def download_file(url: str, cache_dir: str) -> str:
 
 @MCPServer()
 class AudioAnalysisToolkit(BaseToolkit):
-    r"""A toolkit for audio processing and analysis.
-
-    This class provides methods for processing, transcribing, and extracting
-    information from audio data, including direct question answering about
-    audio content.
-
-    Args:
-        cache_dir (Optional[str]): Directory path for caching downloaded audio
-            files. If not provided, 'tmp/' will be used. (default: :obj:`None`)
-        transcribe_model (Optional[BaseAudioModel]): Model used for audio
-            transcription. If not provided, OpenAIAudioModels will be used.
-            (default: :obj:`None`)
-        audio_reasoning_model (Optional[BaseModelBackend]): Model used for
-            audio reasoning and question answering. If not provided, uses the
-            default model from ChatAgent. (default: :obj:`None`)
-    """
-
     def __init__(
         self,
         cache_dir: Optional[str] = None,
         transcribe_model: Optional[BaseAudioModel] = None,
         audio_reasoning_model: Optional[BaseModelBackend] = None,
+        timeout: Optional[float] = None,
     ):
+        r"""A toolkit for audio processing and analysis. This class provides
+        methods for processing, transcribing, and extracting information from
+        audio data, including direct question answering about audio content.
+
+        Args:
+            cache_dir (Optional[str]): Directory path for caching downloaded
+                audio files. If not provided, 'tmp/' will be used.
+                (default: :obj:`None`)
+            transcribe_model (Optional[BaseAudioModel]): Model used for audio
+                transcription. If not provided, OpenAIAudioModels will be used.
+                (default: :obj:`None`)
+            audio_reasoning_model (Optional[BaseModelBackend]): Model used for
+                audio reasoning and question answering.
+                If not provided, uses the default model from ChatAgent.
+                (default: :obj:`None`)
+            timeout (Optional[float]): The timeout value for API requests
+                    in seconds. If None, no timeout is applied.
+                    (default: :obj:`None`)
+        """
+        super().__init__(timeout=timeout)
         self.cache_dir = 'tmp/'
         if cache_dir:
             self.cache_dir = cache_dir

camel/toolkits/browser_toolkit.py

@@ -43,8 +43,9 @@ if TYPE_CHECKING:
 from camel.logger import get_logger
 from camel.messages import BaseMessage
 from camel.models import BaseModelBackend, ModelFactory
-from camel.toolkits import FunctionTool, VideoAnalysisToolkit
 from camel.toolkits.base import BaseToolkit
+from camel.toolkits.function_tool import FunctionTool
+from camel.toolkits.video_analysis_toolkit import VideoAnalysisToolkit
 from camel.types import ModelPlatformType, ModelType
 from camel.utils import dependencies_required, retry_on_error
 
@@ -1175,6 +1176,8 @@ out the information you need. Sometimes they are extremely useful.
         message = BaseMessage.make_user_message(
             role_name='user', content=observe_prompt, image_list=[img]
         )
+        # Reset the history message of web_agent.
+        self.web_agent.reset()
         resp = self.web_agent.step(message)
 
         resp_content = resp.msgs[0].content
@@ -1404,6 +1407,8 @@ Your output should be in json format, including the following fields:
 - `if_need_replan`: bool, A boolean value indicating whether the task needs to be fundamentally replanned.
 - `replanned_schema`: str, The replanned schema for the task, which should not be changed too much compared with the original one. If the task does not need to be replanned, the value should be an empty string. 
 """
+        # Reset the history message of planning_agent.
+        self.planning_agent.reset()
         resp = self.planning_agent.step(replanning_prompt)
         resp_dict = _parse_json_output(resp.msgs[0].content)
 

camel/toolkits/dalle_toolkit.py

@@ -22,13 +22,28 @@ from PIL import Image
 
 from camel.toolkits import FunctionTool
 from camel.toolkits.base import BaseToolkit
+from camel.utils import MCPServer
 
 
+@MCPServer()
 class DalleToolkit(BaseToolkit):
     r"""A class representing a toolkit for image generation using OpenAI's
     DALL-E model.
     """
 
+    def __init__(
+        self,
+        timeout: Optional[float] = None,
+    ):
+        r"""Initializes a new instance of the DalleToolkit class.
+
+        Args:
+            timeout (Optional[float]): The timeout value for API requests
+                in seconds. If None, no timeout is applied.
+                (default: :obj:`None`)
+        """
+        super().__init__(timeout=timeout)
+
     def base64_to_image(self, base64_string: str) -> Optional[Image.Image]:
         r"""Converts a base64 encoded string into a PIL Image object.
 

camel/toolkits/excel_toolkit.py

@@ -12,7 +12,7 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
-from typing import List
+from typing import List, Optional
 
 import pandas as pd
 
@@ -33,6 +33,19 @@ class ExcelToolkit(BaseToolkit):
     process excel files.
     """
 
+    def __init__(
+        self,
+        timeout: Optional[float] = None,
+    ):
+        r"""Initializes a new instance of the ExcelToolkit class.
+
+        Args:
+            timeout (Optional[float]): The timeout value for API requests
+                in seconds. If None, no timeout is applied.
+                (default: :obj:`None`)
+        """
+        super().__init__(timeout=timeout)
+
     def _convert_to_markdown(self, df: pd.DataFrame) -> str:
         r"""Convert DataFrame to Markdown format table.
 

camel/toolkits/image_analysis_toolkit.py

@@ -36,7 +36,11 @@ class ImageAnalysisToolkit(BaseToolkit):
     The toolkit uses vision-capable language models to perform these tasks.
     """
 
-    def __init__(self, model: Optional[BaseModelBackend] = None):
+    def __init__(
+        self,
+        model: Optional[BaseModelBackend] = None,
+        timeout: Optional[float] = None,
+    ):
         r"""Initialize the ImageAnalysisToolkit.
 
         Args:
@@ -45,7 +49,11 @@ class ImageAnalysisToolkit(BaseToolkit):
                 images for tasks like image description and visual question
                 answering. If None, a default model will be created using
                 ModelFactory. (default: :obj:`None`)
+            timeout (Optional[float]): The timeout value for API requests
+                in seconds. If None, no timeout is applied.
+                (default: :obj:`None`)
         """
+        super().__init__(timeout=timeout)
         if model:
             self.model = model
         else:

camel/toolkits/mcp_toolkit.py

@@ -314,6 +314,7 @@ class MCPClient(BaseToolkit):
             "type": "object",
             "properties": properties,
             "required": required,
+            "additionalProperties": False,
         }
 
         return {
@@ -322,6 +323,7 @@ class MCPClient(BaseToolkit):
                 "name": mcp_tool.name,
                 "description": mcp_tool.description
                 or "No description provided.",
+                "strict": True,
                 "parameters": parameters,
             },
         }

camel/toolkits/networkx_toolkit.py

@@ -38,6 +38,7 @@ class NetworkXToolkit(BaseToolkit):
 
     def __init__(
         self,
+        timeout: Optional[float] = None,
         graph_type: Literal[
             'graph', 'digraph', 'multigraph', 'multidigraph'
         ] = 'graph',
@@ -53,7 +54,11 @@ class NetworkXToolkit(BaseToolkit):
                 - 'multigraph': Undirected graph with parallel edges
                 - 'multidigraph': Directed graph with parallel edges
                 (default: :obj:`'graph'`)
+            timeout (Optional[float]): The timeout value for API requests
+                in seconds. If None, no timeout is applied.
+                (default: :obj:`None`)
         """
+        super().__init__(timeout=timeout)
         nx = self._get_nx()
         graph_types = {
             'graph': nx.Graph,

camel/toolkits/openai_agent_toolkit.py

@@ -45,6 +45,7 @@ class OpenAIAgentToolkit(BaseToolkit):
         self,
         model: Optional[BaseModelBackend] = None,
         api_key: Optional[str] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         r"""Initialize the OpenAI agent toolkit.
 
@@ -53,8 +54,11 @@ class OpenAIAgentToolkit(BaseToolkit):
                 If None, defaults to gpt-4o-mini. (default: :obj:`None`)
             api_key (str): OpenAI API key. If not provided, will attempt to
                 use OPENAI_API_KEY environment variable. (default: :obj:`None`)
+            timeout (Optional[float]): The timeout value for API requests
+                in seconds. If None, no timeout is applied.
+                (default: :obj:`None`)
         """
-        super().__init__()
+        super().__init__(timeout=timeout)
         self.api_key = api_key or os.getenv("OPENAI_API_KEY")
         self.client = OpenAI(api_key=self.api_key)
         self.model = model or ModelFactory.create(

camel/toolkits/searxng_toolkit.py

@@ -20,10 +20,12 @@ import requests
 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 SearxNGToolkit(BaseToolkit):
     r"""A toolkit for performing web searches using SearxNG search engine.
 
@@ -42,6 +44,9 @@ class SearxNGToolkit(BaseToolkit):
             values are "day", "week", "month", "year". (default: :obj:`None`)
         safe_search (int, optional): Safe search level (0: None, 1: Moderate,
             2: Strict). (default: :obj:`1`)
+        timeout (Optional[float]): The timeout value for API requests
+                in seconds. If None, no timeout is applied.
+                (default: :obj:`None`)
 
     Raises:
         ValueError: If searxng_host is not a valid HTTP/HTTPS URL.
@@ -65,7 +70,9 @@ class SearxNGToolkit(BaseToolkit):
         categories: Optional[List[str]] = None,
         time_range: Optional[str] = None,
         safe_search: int = 1,
+        timeout: Optional[float] = None,
     ) -> None:
+        super().__init__(timeout=timeout)
         self._validate_searxng_host(searxng_host)
         self._validate_safe_search(safe_search)
         if time_range is not None:

camel/toolkits/slack_toolkit.py

@@ -15,7 +15,6 @@
 from __future__ import annotations
 
 import json
-import logging
 import os
 from typing import TYPE_CHECKING, List, Optional
 
@@ -27,9 +26,10 @@ if TYPE_CHECKING:
 
     from slack_sdk import WebClient
 
+from camel.logger import get_logger
 from camel.toolkits import FunctionTool
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 
 @MCPServer()
@@ -40,6 +40,19 @@ class SlackToolkit(BaseToolkit):
     channel, joining an existing channel, leaving a channel.
     """
 
+    def __init__(
+        self,
+        timeout: Optional[float] = None,
+    ):
+        r"""Initializes a new instance of the SlackToolkit class.
+
+        Args:
+            timeout (Optional[float]): The timeout value for API requests
+                in seconds. If None, no timeout is applied.
+                (default: :obj:`None`)
+        """
+        super().__init__(timeout=timeout)
+
     def _login_slack(
         self,
         slack_token: Optional[str] = None,

camel/toolkits/video_analysis_toolkit.py

@@ -92,6 +92,9 @@ class VideoAnalysisToolkit(BaseToolkit):
             transcription using OpenAI's audio models. Requires a valid OpenAI
             API key. When disabled, video analysis will be based solely on
             visual content. (default: :obj:`False`)
+        timeout (Optional[float]): The timeout value for API requests
+                in seconds. If None, no timeout is applied.
+                (default: :obj:`None`)
     """
 
     @dependencies_required("ffmpeg", "scenedetect")
@@ -100,7 +103,9 @@ class VideoAnalysisToolkit(BaseToolkit):
         download_directory: Optional[str] = None,
         model: Optional[BaseModelBackend] = None,
         use_audio_transcription: bool = False,
+        timeout: Optional[float] = None,
     ) -> None:
+        super().__init__(timeout=timeout)
         self._cleanup = download_directory is None
         self._temp_files: list[str] = []  # Track temporary files for cleanup
         self._use_audio_transcription = use_audio_transcription

camel/toolkits/weather_toolkit.py

@@ -12,7 +12,7 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import os
-from typing import List, Literal
+from typing import List, Literal, Optional
 
 from camel.toolkits.base import BaseToolkit
 from camel.toolkits.function_tool import FunctionTool
@@ -27,6 +27,19 @@ class WeatherToolkit(BaseToolkit):
     using the OpenWeatherMap API.
     """
 
+    def __init__(
+        self,
+        timeout: Optional[float] = None,
+    ):
+        r"""Initializes a new instance of the WeatherToolkit class.
+
+        Args:
+            timeout (Optional[float]): The timeout value for API requests
+                in seconds. If None, no timeout is applied.
+                (default: :obj:`None`)
+        """
+        super().__init__(timeout=timeout)
+
     def get_openweathermap_api_key(self) -> str:
         r"""Retrieve the OpenWeatherMap API key from environment variables.