camel-ai 0.2.24__tar.gz → 0.2.25__tar.gz

{camel_ai-0.2.24 → camel_ai-0.2.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.24
+Version: 0.2.25
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel

{camel_ai-0.2.24 → camel_ai-0.2.25}/camel/__init__.py

@@ -14,7 +14,7 @@
 
 from camel.logger import disable_logging, enable_logging, set_log_level
 
-__version__ = '0.2.24'
+__version__ = '0.2.25'
 
 __all__ = [
     '__version__',

{camel_ai-0.2.24 → camel_ai-0.2.25}/camel/configs/sglang_config.py

@@ -13,7 +13,7 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from __future__ import annotations
 
-from typing import Sequence, Union
+from typing import Any, Dict, List, Optional, Sequence, Union
 
 from camel.configs.base_config import BaseConfig
 from camel.types import NOT_GIVEN, NotGiven
@@ -56,10 +56,11 @@ class SGLangConfig(BaseConfig):
             in the chat completion. The total length of input tokens and
             generated tokens is limited by the model's context length.
             (default: :obj:`None`)
-        tools (list[FunctionTool], optional): A list of tools the model may
-            call. Currently, only functions are supported as a tool. Use this
-            to provide a list of functions the model may generate JSON inputs
-            for. A max of 128 functions are supported.
+        tools (list[Dict[str, Any]], optional): A list of tool definitions
+            that the model can dynamically invoke. Each tool should be
+            defined as a dictionary following OpenAI's function calling
+            specification format. For more details, refer to the OpenAI
+            documentation.
     """
 
     stop: Union[str, Sequence[str], NotGiven] = NOT_GIVEN
@@ -70,6 +71,7 @@ class SGLangConfig(BaseConfig):
     presence_penalty: float = 0.0
     stream: bool = False
     max_tokens: Union[int, NotGiven] = NOT_GIVEN
+    tools: Optional[Union[List[Dict[str, Any]]]] = None
 
 
 SGLANG_API_PARAMS = {param for param in SGLangConfig.model_fields.keys()}

{camel_ai-0.2.24 → camel_ai-0.2.25}/camel/interpreters/subprocess_interpreter.py

@@ -12,8 +12,9 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
-import shlex
+import os
 import subprocess
+import sys
 import tempfile
 from pathlib import Path
 from typing import Any, ClassVar, Dict, List
@@ -43,12 +44,14 @@ class SubprocessInterpreter(BaseInterpreter):
             the executed code. (default: :obj:`False`)
         print_stderr (bool, optional): If True, print the standard error of the
             executed code. (default: :obj:`True`)
+        execution_timeout (int, optional): Maximum time in seconds to wait for
+            code execution to complete. (default: :obj:`60`)
     """
 
-    _CODE_EXECUTE_CMD_MAPPING: ClassVar[Dict[str, str]] = {
-        "python": "python {file_name}",
-        "bash": "bash {file_name}",
-        "r": "Rscript {file_name}",
+    _CODE_EXECUTE_CMD_MAPPING: ClassVar[Dict[str, Dict[str, str]]] = {
+        "python": {"posix": "python {file_name}", "nt": "python {file_name}"},
+        "bash": {"posix": "bash {file_name}", "nt": "bash {file_name}"},
+        "r": {"posix": "Rscript {file_name}", "nt": "Rscript {file_name}"},
     }
 
     _CODE_EXTENSION_MAPPING: ClassVar[Dict[str, str]] = {
@@ -74,10 +77,12 @@ class SubprocessInterpreter(BaseInterpreter):
         require_confirm: bool = True,
         print_stdout: bool = False,
         print_stderr: bool = True,
+        execution_timeout: int = 60,
     ) -> None:
         self.require_confirm = require_confirm
         self.print_stdout = print_stdout
         self.print_stderr = print_stderr
+        self.execution_timeout = execution_timeout
 
     def run_file(
         self,
@@ -94,13 +99,9 @@ class SubprocessInterpreter(BaseInterpreter):
         Returns:
             str: A string containing the captured stdout and stderr of the
                 executed code.
-
-        Raises:
-            RuntimeError: If the provided file path does not point to a file.
-            InterpreterError: If the code type provided is not supported.
         """
         if not file.is_file():
-            raise RuntimeError(f"{file} is not a file.")
+            return f"{file} is not a file."
         code_type = self._check_code_type(code_type)
         if self._CODE_TYPE_MAPPING[code_type] == "python":
             # For Python code, use ast to analyze and modify the code
@@ -108,7 +109,7 @@ class SubprocessInterpreter(BaseInterpreter):
 
             import astor
 
-            with open(file, 'r') as f:
+            with open(file, 'r', encoding='utf-8') as f:
                 source = f.read()
 
             # Parse the source code
@@ -158,34 +159,88 @@ class SubprocessInterpreter(BaseInterpreter):
                     modified_source = astor.to_source(tree)
                     # Create a temporary file with the modified source
                     temp_file = self._create_temp_file(modified_source, "py")
-                    cmd = shlex.split(f"python {temp_file!s}")
-            except SyntaxError:
-                # If parsing fails, run the original file
-                cmd = shlex.split(
-                    self._CODE_EXECUTE_CMD_MAPPING[code_type].format(
-                        file_name=str(file)
+                    cmd = ["python", str(temp_file)]
+            except (SyntaxError, TypeError, ValueError) as e:
+                logger.warning(f"Failed to parse Python code with AST: {e}")
+                platform_type = 'posix' if os.name != 'nt' else 'nt'
+                cmd_template = self._CODE_EXECUTE_CMD_MAPPING[code_type][
+                    platform_type
+                ]
+                base_cmd = cmd_template.split()[0]
+
+                # Check if command is available
+                if not self._is_command_available(base_cmd):
+                    raise InterpreterError(
+                        f"Command '{base_cmd}' not found. Please ensure it "
+                        f"is installed and available in your PATH."
                     )
-                )
+
+                cmd = [base_cmd, str(file)]
         else:
             # For non-Python code, use standard execution
-            cmd = shlex.split(
-                self._CODE_EXECUTE_CMD_MAPPING[code_type].format(
-                    file_name=str(file)
+            platform_type = 'posix' if os.name != 'nt' else 'nt'
+            cmd_template = self._CODE_EXECUTE_CMD_MAPPING[code_type][
+                platform_type
+            ]
+            base_cmd = cmd_template.split()[0]  # Get 'python', 'bash', etc.
+
+            # Check if command is available
+            if not self._is_command_available(base_cmd):
+                raise InterpreterError(
+                    f"Command '{base_cmd}' not found. Please ensure it "
+                    f"is installed and available in your PATH."
                 )
-            )
 
-        proc = subprocess.Popen(
-            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
-        )
-        stdout, stderr = proc.communicate()
-        return_code = proc.returncode
+            cmd = [base_cmd, str(file)]
+
+        # Get current Python executable's environment
+        env = os.environ.copy()
+
+        # On Windows, ensure we use the correct Python executable path
+        if os.name == 'nt':
+            python_path = os.path.dirname(sys.executable)
+            if 'PATH' in env:
+                env['PATH'] = python_path + os.pathsep + env['PATH']
+            else:
+                env['PATH'] = python_path
+
+        try:
+            proc = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                env=env,
+                shell=False,  # Never use shell=True for security
+            )
+            # Add timeout to prevent hanging processes
+            stdout, stderr = proc.communicate(timeout=self.execution_timeout)
+            return_code = proc.returncode
+        except subprocess.TimeoutExpired:
+            proc.kill()
+            stdout, stderr = proc.communicate()
+            return_code = proc.returncode
+            timeout_msg = (
+                f"Process timed out after {self.execution_timeout} seconds "
+                f"and was terminated."
+            )
+            stderr = f"{stderr}\n{timeout_msg}"
 
         # Clean up temporary file if it was created
-        if (
-            self._CODE_TYPE_MAPPING[code_type] == "python"
-            and 'temp_file' in locals()
-        ):
-            temp_file.unlink()
+        temp_file_to_clean = locals().get('temp_file')
+        if temp_file_to_clean is not None:
+            try:
+                if temp_file_to_clean.exists():
+                    try:
+                        temp_file_to_clean.unlink()
+                    except PermissionError:
+                        # On Windows, files might be locked
+                        logger.warning(
+                            f"Could not delete temp file "
+                            f"{temp_file_to_clean} (may be locked)"
+                        )
+            except Exception as e:
+                logger.warning(f"Failed to cleanup temporary file: {e}")
 
         if self.print_stdout and stdout:
             print("======stdout======")
@@ -240,7 +295,7 @@ class SubprocessInterpreter(BaseInterpreter):
                 "computer: {code}"
             )
             while True:
-                choice = input("Running code? [Y/n]:").lower()
+                choice = input("Running code? [Y/n]:").lower().strip()
                 if choice in ["y", "yes", "ye", ""]:
                     break
                 elif choice in ["no", "n"]:
@@ -249,22 +304,72 @@ class SubprocessInterpreter(BaseInterpreter):
                         "This choice stops the current operation and any "
                         "further code execution."
                     )
-        temp_file_path = self._create_temp_file(
-            code=code, extension=self._CODE_EXTENSION_MAPPING[code_type]
-        )
+                else:
+                    print("Please enter 'y' or 'n'.")
+
+        temp_file_path = None
+        temp_dir = None
+        try:
+            temp_file_path = self._create_temp_file(
+                code=code, extension=self._CODE_EXTENSION_MAPPING[code_type]
+            )
+            temp_dir = temp_file_path.parent
+            return self.run_file(temp_file_path, code_type)
+        finally:
+            # Clean up temp file and directory
+            try:
+                if temp_file_path and temp_file_path.exists():
+                    try:
+                        temp_file_path.unlink()
+                    except PermissionError:
+                        # On Windows, files might be locked
+                        logger.warning(
+                            f"Could not delete temp file {temp_file_path}"
+                        )
+
+                if temp_dir and temp_dir.exists():
+                    try:
+                        import shutil
+
+                        shutil.rmtree(temp_dir, ignore_errors=True)
+                    except Exception as e:
+                        logger.warning(f"Could not delete temp directory: {e}")
+            except Exception as e:
+                logger.warning(f"Error during cleanup: {e}")
 
-        result = self.run_file(temp_file_path, code_type)
+    def _create_temp_file(self, code: str, extension: str) -> Path:
+        r"""Creates a temporary file with the given code and extension.
 
-        temp_file_path.unlink()
-        return result
+        Args:
+            code (str): The code to write to the temporary file.
+            extension (str): The file extension to use.
 
-    def _create_temp_file(self, code: str, extension: str) -> Path:
-        with tempfile.NamedTemporaryFile(
-            mode="w", delete=False, suffix=f".{extension}"
-        ) as f:
-            f.write(code)
-            name = f.name
-        return Path(name)
+        Returns:
+            Path: The path to the created temporary file.
+        """
+        try:
+            # Create a temporary directory first to ensure we have write
+            # permissions
+            temp_dir = tempfile.mkdtemp()
+            # Create file path with appropriate extension
+            file_path = Path(temp_dir) / f"temp_code.{extension}"
+
+            # Write code to file with appropriate encoding
+            with open(file_path, 'w', encoding='utf-8') as f:
+                f.write(code)
+
+            return file_path
+        except Exception as e:
+            # Clean up temp directory if creation failed
+            if 'temp_dir' in locals():
+                try:
+                    import shutil
+
+                    shutil.rmtree(temp_dir, ignore_errors=True)
+                except Exception:
+                    pass
+            logger.error(f"Failed to create temporary file: {e}")
+            raise
 
     def _check_code_type(self, code_type: str) -> str:
         if code_type not in self._CODE_TYPE_MAPPING:
@@ -284,3 +389,39 @@ class SubprocessInterpreter(BaseInterpreter):
         raise RuntimeError(
             "SubprocessInterpreter doesn't support " "`action_space`."
         )
+
+    def _is_command_available(self, command: str) -> bool:
+        r"""Check if a command is available in the system PATH.
+
+        Args:
+            command (str): The command to check.
+
+        Returns:
+            bool: True if the command is available, False otherwise.
+        """
+        if os.name == 'nt':  # Windows
+            # On Windows, use where.exe to find the command
+            try:
+                with open(os.devnull, 'w') as devnull:
+                    subprocess.check_call(
+                        ['where', command],
+                        stdout=devnull,
+                        stderr=devnull,
+                        shell=False,
+                    )
+                return True
+            except subprocess.CalledProcessError:
+                return False
+        else:  # Unix-like systems
+            # On Unix-like systems, use which to find the command
+            try:
+                with open(os.devnull, 'w') as devnull:
+                    subprocess.check_call(
+                        ['which', command],
+                        stdout=devnull,
+                        stderr=devnull,
+                        shell=False,
+                    )
+                return True
+            except subprocess.CalledProcessError:
+                return False

{camel_ai-0.2.24 → camel_ai-0.2.25}/camel/models/sglang_model.py

@@ -97,9 +97,16 @@ class SGLangModel(BaseModelBackend):
     def _start_server(self) -> None:
         try:
             if not self._url:
+                tool_call_flag = self.model_config_dict.get("tools")
+                tool_call_arg = (
+                    f"--tool-call-parser {self._api_key} "
+                    if tool_call_flag
+                    else ""
+                )
                 cmd = (
                     f"python -m sglang.launch_server "
                     f"--model-path {self.model_type} "
+                    f"{tool_call_arg}"
                     f"--port 30000 "
                     f"--host 0.0.0.0"
                 )
@@ -265,6 +272,19 @@ class SGLangModel(BaseModelBackend):
         """
         return self.model_config_dict.get('stream', False)
 
+    def __del__(self):
+        r"""Properly clean up resources when the model is destroyed."""
+        self.cleanup()
+
+    def cleanup(self):
+        r"""Terminate the server process and clean up resources."""
+        with self._lock:
+            if self.server_process:
+                _terminate_process(self.server_process)
+                self.server_process = None
+                self._client = None
+                logging.info("Server process terminated during cleanup.")
+
 
 # Below are helper functions from sglang.utils
 def _terminate_process(process):
@@ -326,21 +346,25 @@ def _execute_shell_command(command: str) -> subprocess.Popen:
     return subprocess.Popen(parts, text=True, stderr=subprocess.STDOUT)
 
 
-def _wait_for_server(base_url: str, timeout: Optional[int] = None) -> None:
+def _wait_for_server(base_url: str, timeout: Optional[int] = 30) -> None:
     r"""Wait for the server to be ready by polling the /v1/models endpoint.
 
     Args:
         base_url: The base URL of the server
-        timeout: Maximum time to wait in seconds. None means wait forever.
+        timeout: Maximum time to wait in seconds. Default is 30 seconds.
     """
     import requests
 
+    # Set a default value if timeout is None
+    actual_timeout = 30 if timeout is None else timeout
+
     start_time = time.time()
     while True:
         try:
             response = requests.get(
                 f"{base_url}/v1/models",
                 headers={"Authorization": "Bearer None"},
+                timeout=5,  # Add a timeout for the request itself
             )
             if response.status_code == 200:
                 time.sleep(5)
@@ -356,9 +380,15 @@ def _wait_for_server(base_url: str, timeout: Optional[int] = None) -> None:
                 )
                 break
 
-            if timeout and time.time() - start_time > timeout:
+            if time.time() - start_time > actual_timeout:
+                raise TimeoutError(
+                    f"Server did not become ready within "
+                    f"{actual_timeout} seconds"
+                )
+        except (requests.exceptions.RequestException, TimeoutError) as e:
+            if time.time() - start_time > actual_timeout:
                 raise TimeoutError(
-                    "Server did not become ready within timeout period"
+                    f"Server did not become ready within "
+                    f"{actual_timeout} seconds: {e}"
                 )
-        except requests.exceptions.RequestException:
             time.sleep(1)

{camel_ai-0.2.24 → camel_ai-0.2.25}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "camel-ai"
-version = "0.2.24"
+version = "0.2.25"
 description = "Communicative Agents for AI Society Study"
 authors = [{ name = "CAMEL-AI.org" }]
 requires-python = ">=3.10,<3.13"