camel-ai 0.2.59__py3-none-any.whl → 0.2.82__py3-none-any.whl

camel/interpreters/internal_python_interpreter.py

@@ -1,4 +1,4 @@
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# ========= Copyright 2023-2025 @ 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
@@ -10,10 +10,12 @@
 # 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. =========
+# ========= Copyright 2023-2025 @ CAMEL-AI.org. All Rights Reserved. =========
 import ast
 import difflib
 import importlib
+import os
+import subprocess
 import typing
 from typing import Any, ClassVar, Dict, List, Optional
 
@@ -77,6 +79,9 @@ class InternalPythonInterpreter(BaseInterpreter):
             (default: :obj:`False`)
         raise_error (bool, optional): Raise error if the interpreter fails.
             (default: :obj:`False`)
+        allow_builtins (bool, optional): If `True`, safe built-in functions
+            like print, len, str, etc. are added to the action space.
+            (default: :obj:`True`)
     """
 
     _CODE_TYPES: ClassVar[List[str]] = ["python", "py", "python3", "python2"]
@@ -87,6 +92,7 @@ class InternalPythonInterpreter(BaseInterpreter):
         import_white_list: Optional[List[str]] = None,
         unsafe_mode: bool = False,
         raise_error: bool = False,
+        allow_builtins: bool = True,
     ) -> None:
         self.action_space = action_space or dict()
         self.state = self.action_space.copy()
@@ -95,7 +101,54 @@ class InternalPythonInterpreter(BaseInterpreter):
         self.raise_error = raise_error
         self.unsafe_mode = unsafe_mode
 
-    def run(self, code: str, code_type: str) -> str:
+        # Add safe built-in functions if allowed
+        if allow_builtins:
+            self._add_safe_builtins()
+
+    def _add_safe_builtins(self):
+        r"""Add safe built-in functions to the action space."""
+        safe_builtins = {
+            'print': print,
+            'len': len,
+            'str': str,
+            'int': int,
+            'float': float,
+            'bool': bool,
+            'list': list,
+            'dict': dict,
+            'tuple': tuple,
+            'set': set,
+            'abs': abs,
+            'min': min,
+            'max': max,
+            'sum': sum,
+            'sorted': sorted,
+            'reversed': reversed,
+            'enumerate': enumerate,
+            'zip': zip,
+            'range': range,
+            'round': round,
+            'type': type,
+            'isinstance': isinstance,
+            'hasattr': hasattr,
+            'getattr': getattr,
+            'setattr': setattr,
+            'dir': dir,
+            'help': help,
+            'map': map,
+            'filter': filter,
+            'any': any,
+            'all': all,
+            'ord': ord,
+            'chr': chr,
+            'bin': bin,
+            'oct': oct,
+            'hex': hex,
+        }
+        self.action_space.update(safe_builtins)
+        self.state.update(safe_builtins)
+
+    def run(self, code: str, code_type: str = "python") -> str:
         r"""Executes the given code with specified code type in the
         interpreter.
 
@@ -111,7 +164,7 @@ class InternalPythonInterpreter(BaseInterpreter):
             code (str): The python code to be executed.
             code_type (str): The type of the code, which should be one of the
             supported code types (`python`, `py`, `python3`, `python2`).
-
+                (default: obj:`python`)
 
         Returns:
             str: The string representation of the output of the executed code.
@@ -531,3 +584,27 @@ class InternalPythonInterpreter(BaseInterpreter):
                 return self.fuzz_state[close_matches[0]]
             else:
                 raise InterpreterError(f"The variable `{key}` is not defined.")
+
+    def execute_command(self, command: str) -> tuple[str, str]:
+        r"""Execute a command in the internal python interpreter.
+
+        Args:
+            command (str): The command to execute.
+
+        Returns:
+            tuple: A tuple containing the stdout and stderr of the command.
+        """
+        try:
+            proc = subprocess.Popen(
+                command,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                env=os.environ,
+                shell=True,
+            )
+            stdout, stderr = proc.communicate()
+
+            return stdout, stderr
+        except Exception as e:
+            raise InterpreterError(f"Error executing command: {e}")

camel/interpreters/interpreter_error.py

@@ -1,4 +1,4 @@
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# ========= Copyright 2023-2025 @ 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
@@ -10,7 +10,7 @@
 # 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. =========
+# ========= Copyright 2023-2025 @ CAMEL-AI.org. All Rights Reserved. =========
 
 # TODO: Do we need a file to store this error class?
 class InterpreterError(Exception):

camel/interpreters/ipython_interpreter.py

@@ -1,4 +1,4 @@
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# ========= Copyright 2023-2025 @ 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
@@ -10,7 +10,7 @@
 # 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. =========
+# ========= Copyright 2023-2025 @ CAMEL-AI.org. All Rights Reserved. =========
 
 import queue
 import re
@@ -118,13 +118,13 @@ class JupyterKernelInterpreter(BaseInterpreter):
         exec_result = "\n".join(outputs)
         return self._clean_ipython_output(exec_result)
 
-    def run(self, code: str, code_type: str) -> str:
+    def run(self, code: str, code_type: str = "python") -> str:
         r"""Executes the given code in the Jupyter kernel.
 
         Args:
             code (str): The code string to execute.
             code_type (str): The type of code to execute (e.g., 'python',
-                'bash').
+                'bash'). (default: obj:`python`)
 
         Returns:
             str: A string containing the captured result of the
@@ -144,6 +144,24 @@ class JupyterKernelInterpreter(BaseInterpreter):
 
         return result
 
+    def execute_command(self, command: str) -> str:
+        r"""Executes a shell command in the Jupyter kernel.
+
+        Args:
+            command (str): The shell command to execute.
+
+        Returns:
+            str: A string containing the captured result of the
+                executed command.
+
+        """
+        try:
+            self._initialize_if_needed()
+            system_command = f"!{command}"
+            return self._execute(system_command, TIMEOUT)
+        except Exception as e:
+            raise InterpreterError(f"Error executing command: {e}")
+
     def supported_code_types(self) -> List[str]:
         r"""Provides supported code types by the interpreter.
 
@@ -164,5 +182,5 @@ class JupyterKernelInterpreter(BaseInterpreter):
                 does not support updating the action space.
         """
         raise RuntimeError(
-            "SubprocessInterpreter doesn't support " "`action_space`."
+            "JupyterKernelInterpreter doesn't support " "`action_space`."
         )

camel/interpreters/microsandbox_interpreter.py

@@ -0,0 +1,395 @@
+# ========= Copyright 2023-2025 @ 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-2025 @ CAMEL-AI.org. All Rights Reserved. =========
+import asyncio
+from typing import Any, ClassVar, Dict, List, Optional, Tuple, Union
+
+from camel.interpreters.base import BaseInterpreter
+from camel.interpreters.interpreter_error import InterpreterError
+from camel.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class MicrosandboxInterpreter(BaseInterpreter):
+    r"""Microsandbox Code Interpreter implementation.
+
+    This interpreter provides secure code execution using microsandbox,
+    a self-hosted platform for secure execution of untrusted user/AI code.
+    It supports Python code execution via PythonSandbox, JavaScript/Node.js
+    code execution via NodeSandbox, and shell commands via the command
+    interface.
+
+    Args:
+        require_confirm (bool, optional): If True, prompt user before running
+            code strings for security. (default: :obj:`True`)
+        server_url (str, optional): URL of the microsandbox server. If not
+            provided, will use MSB_SERVER_URL environment variable, then
+            fall back to http://127.0.0.1:5555. (default: :obj:`None`)
+        api_key (str, optional): API key for microsandbox authentication.
+            If not provided, will use MSB_API_KEY environment variable.
+            (default: :obj:`None`)
+        namespace (str, optional): Namespace for the sandbox.
+            (default: :obj:`"default"`)
+        sandbox_name (str, optional): Name of the sandbox instance. If not
+            provided, a random name will be generated by the SDK.
+            (default: :obj:`None`)
+        timeout (int, optional): Default timeout for code execution in seconds.
+            (default: :obj:`30`)
+
+    Environment Variables:
+        MSB_SERVER_URL: URL of the microsandbox server.
+        MSB_API_KEY: API key for microsandbox authentication.
+
+    Note:
+        The SDK handles parameter priority as: user parameter > environment
+            variable > default value.
+    """
+
+    _CODE_TYPE_MAPPING: ClassVar[Dict[str, str]] = {
+        # Python code - uses PythonSandbox
+        "python": "python_sandbox",
+        "py3": "python_sandbox",
+        "python3": "python_sandbox",
+        "py": "python_sandbox",
+        # JavaScript/Node.js code - uses NodeSandbox
+        "javascript": "node_sandbox",
+        "js": "node_sandbox",
+        "node": "node_sandbox",
+        "typescript": "node_sandbox",
+        "ts": "node_sandbox",
+        # Shell commands - uses command.run()
+        "bash": "shell_command",
+        "shell": "shell_command",
+        "sh": "shell_command",
+    }
+
+    def __init__(
+        self,
+        require_confirm: bool = True,
+        server_url: Optional[str] = None,
+        api_key: Optional[str] = None,
+        namespace: str = "default",
+        sandbox_name: Optional[str] = None,
+        timeout: int = 30,
+    ) -> None:
+        from microsandbox import (
+            NodeSandbox,
+            PythonSandbox,
+        )
+
+        # Store parameters, let SDK handle defaults and environment variables
+        self.require_confirm = require_confirm
+        self.server_url = server_url  # None means use SDK default logic
+        self.api_key = api_key  # None means use SDK default logic
+        self.namespace = namespace
+        self.sandbox_name = (
+            sandbox_name  # None means SDK generates random name
+        )
+        self.timeout = timeout
+
+        # Store sandbox configuration
+        self._sandbox_config = {
+            "server_url": self.server_url,
+            "namespace": self.namespace,
+            "name": self.sandbox_name,
+            "api_key": self.api_key,
+        }
+
+        # Store sandbox classes for reuse
+        self._PythonSandbox = PythonSandbox
+        self._NodeSandbox = NodeSandbox
+
+        # Log initialization info
+        logger.info("Initialized MicrosandboxInterpreter")
+        logger.info(f"Namespace: {self.namespace}")
+        if self.sandbox_name:
+            logger.info(f"Sandbox name: {self.sandbox_name}")
+        else:
+            logger.info("Sandbox name: will be auto-generated by SDK")
+
+    def run(
+        self,
+        code: str,
+        code_type: str = "python",
+    ) -> str:
+        r"""Executes the given code in the microsandbox.
+
+        Args:
+            code (str): The code string to execute.
+            code_type (str): The type of code to execute. Supported types:
+                'python', 'javascript', 'bash'. (default: :obj:`python`)
+
+        Returns:
+            str: The string representation of the output of the executed code.
+
+        Raises:
+            InterpreterError: If the `code_type` is not supported or if any
+                runtime error occurs during the execution of the code.
+        """
+        if code_type not in self._CODE_TYPE_MAPPING:
+            raise InterpreterError(
+                f"Unsupported code type {code_type}. "
+                f"`{self.__class__.__name__}` only supports "
+                f"{', '.join(list(self._CODE_TYPE_MAPPING.keys()))}."
+            )
+
+        # Print code for security checking
+        if self.require_confirm:
+            logger.info(
+                f"The following {code_type} code will run on "
+                f"microsandbox: {code}"
+            )
+            self._confirm_execution("code")
+
+        # Run the code asynchronously
+        return asyncio.run(self._run_async(code, code_type))
+
+    async def _run_async(self, code: str, code_type: str) -> str:
+        r"""Asynchronously executes code in microsandbox.
+
+        Args:
+            code (str): The code to execute.
+            code_type (str): The type of code to execute.
+
+        Returns:
+            str: The output of the executed code.
+
+        Raises:
+            InterpreterError: If execution fails.
+        """
+        try:
+            execution_method = self._CODE_TYPE_MAPPING[code_type]
+
+            if execution_method == "python_sandbox":
+                return await self._run_python_code(code)
+            elif execution_method == "node_sandbox":
+                return await self._run_node_code(code)
+            elif execution_method == "shell_command":
+                return await self._run_shell_command(code)
+            else:
+                raise InterpreterError(
+                    f"Unsupported execution method: {execution_method}"
+                )
+
+        except Exception as e:
+            raise InterpreterError(
+                f"Error executing code in microsandbox: {e}"
+            )
+
+    async def _run_python_code(self, code: str) -> str:
+        r"""Execute Python code using PythonSandbox.
+
+        Args:
+            code (str): Python code to execute.
+
+        Returns:
+            str: Execution output.
+        """
+        async with self._PythonSandbox.create(
+            **self._sandbox_config
+        ) as sandbox:
+            execution = await asyncio.wait_for(
+                sandbox.run(code), timeout=self.timeout
+            )
+            return await self._get_execution_output(execution)
+
+    async def _run_node_code(self, code: str) -> str:
+        r"""Execute JavaScript/Node.js code using NodeSandbox.
+
+        Args:
+            code (str): JavaScript/Node.js code to execute.
+
+        Returns:
+            str: Execution output.
+        """
+        async with self._NodeSandbox.create(**self._sandbox_config) as sandbox:
+            execution = await asyncio.wait_for(
+                sandbox.run(code), timeout=self.timeout
+            )
+            return await self._get_execution_output(execution)
+
+    async def _run_shell_command(self, code: str) -> str:
+        r"""Execute shell commands directly.
+
+        Args:
+            code (str): Shell command to execute.
+
+        Returns:
+            str: Command execution output.
+        """
+        # Use any sandbox for shell commands
+        async with self._PythonSandbox.create(
+            **self._sandbox_config
+        ) as sandbox:
+            execution = await asyncio.wait_for(
+                sandbox.command.run("bash", ["-c", code]), timeout=self.timeout
+            )
+            return await self._get_command_output(execution)
+
+    async def _get_execution_output(self, execution) -> str:
+        r"""Get output from code execution.
+
+        Args:
+            execution: Execution object from sandbox.run().
+
+        Returns:
+            str: Formatted execution output.
+        """
+        output = await execution.output()
+        error = await execution.error()
+
+        result_parts = []
+        if output and output.strip():
+            result_parts.append(output.strip())
+        if error and error.strip():
+            result_parts.append(f"STDERR: {error.strip()}")
+
+        return (
+            "\n".join(result_parts)
+            if result_parts
+            else "Code executed successfully (no output)"
+        )
+
+    async def _get_command_output(self, execution) -> str:
+        r"""Get output from command execution.
+
+        Args:
+            execution: CommandExecution object from sandbox.command.run().
+
+        Returns:
+            str: Formatted command output.
+        """
+        output = await execution.output()
+        error = await execution.error()
+
+        result_parts = []
+        if output and output.strip():
+            result_parts.append(output.strip())
+        if error and error.strip():
+            result_parts.append(f"STDERR: {error.strip()}")
+        if hasattr(execution, 'exit_code') and execution.exit_code != 0:
+            result_parts.append(f"Exit code: {execution.exit_code}")
+
+        return (
+            "\n".join(result_parts)
+            if result_parts
+            else "Command executed successfully (no output)"
+        )
+
+    def _confirm_execution(self, execution_type: str) -> None:
+        r"""Prompt user for confirmation before executing code or commands.
+
+        Args:
+            execution_type (str): Type of execution ('code' or 'command').
+
+        Raises:
+            InterpreterError: If user declines to run the code/command.
+        """
+        while True:
+            choice = input(f"Running {execution_type}? [Y/n]:").lower()
+            if choice in ["y", "yes", "ye"]:
+                break
+            elif choice not in ["no", "n"]:
+                continue
+            raise InterpreterError(
+                f"Execution halted: User opted not to run the "
+                f"{execution_type}. "
+                f"This choice stops the current operation and any "
+                f"further {execution_type} execution."
+            )
+
+    def supported_code_types(self) -> List[str]:
+        r"""Provides supported code types by the interpreter."""
+        return list(self._CODE_TYPE_MAPPING.keys())
+
+    def update_action_space(self, action_space: Dict[str, Any]) -> None:
+        r"""Updates action space for interpreter.
+
+        Args:
+            action_space: Action space dictionary (unused in microsandbox).
+
+        Note:
+            Microsandbox doesn't support action space updates as it runs
+            in isolated environments for each execution.
+        """
+        # Explicitly acknowledge the parameter to avoid linting warnings
+        _ = action_space
+        logger.warning(
+            "Microsandbox doesn't support action space updates. "
+            "Code runs in isolated environments for each execution."
+        )
+
+    def execute_command(self, command: str) -> Union[str, Tuple[str, str]]:
+        r"""Execute a shell command in the microsandbox.
+
+        This method is designed for package management and system
+        administration tasks. It executes shell commands directly
+        using the microsandbox command interface.
+
+        Args:
+            command (str): The shell command to execute (e.g.,
+            "pip install numpy", "ls -la", "apt-get update").
+
+        Returns:
+            Union[str, Tuple[str, str]]: The output of the command.
+
+        Examples:
+            >>> interpreter.execute_command("pip install numpy")
+            >>> interpreter.execute_command("npm install express")
+            >>> interpreter.execute_command("ls -la /tmp")
+        """
+        # Print command for security checking
+        if self.require_confirm:
+            logger.info(
+                f"The following shell command will run on "
+                f"microsandbox: {command}"
+            )
+            self._confirm_execution("command")
+
+        return asyncio.run(self._execute_command_async(command))
+
+    async def _execute_command_async(self, command: str) -> str:
+        r"""Asynchronously executes a shell command in microsandbox.
+
+        Args:
+            command (str): The shell command to execute.
+
+        Returns:
+            str: The output of the command execution.
+
+        Raises:
+            InterpreterError: If execution fails.
+        """
+        try:
+            async with self._PythonSandbox.create(
+                **self._sandbox_config
+            ) as sandbox:
+                execution = await asyncio.wait_for(
+                    sandbox.command.run("bash", ["-c", command]),
+                    timeout=self.timeout,
+                )
+                return await self._get_command_output(execution)
+
+        except Exception as e:
+            raise InterpreterError(
+                f"Error executing command in microsandbox: {e}"
+            )
+
+    def __del__(self) -> None:
+        r"""Destructor for the MicrosandboxInterpreter class.
+
+        Microsandbox uses context managers for resource management,
+        so no explicit cleanup is needed.
+        """
+        logger.debug("MicrosandboxInterpreter cleaned up")

camel/interpreters/subprocess_interpreter.py

@@ -1,4 +1,4 @@
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# ========= Copyright 2023-2025 @ 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
@@ -10,7 +10,7 @@
 # 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. =========
+# ========= Copyright 2023-2025 @ CAMEL-AI.org. All Rights Reserved. =========
 
 import os
 import subprocess
@@ -87,14 +87,14 @@ class SubprocessInterpreter(BaseInterpreter):
     def run_file(
         self,
         file: Path,
-        code_type: str,
+        code_type: str = "python",
     ) -> str:
         r"""Executes a code file in a subprocess and captures its output.
 
         Args:
             file (Path): The path object of the file to run.
             code_type (str): The type of code to execute (e.g., 'python',
-                'bash').
+                'bash'). (default: obj:`python`)
 
         Returns:
             str: A string containing the captured stdout and stderr of the
@@ -425,3 +425,35 @@ class SubprocessInterpreter(BaseInterpreter):
                 return True
             except subprocess.CalledProcessError:
                 return False
+
+    def execute_command(self, command: str) -> tuple[str, str]:
+        r"""Executes a shell command in a subprocess and captures its output.
+
+        Args:
+            command (str): The shell command to execute.
+
+        Returns:
+            tuple: A tuple containing the captured stdout and stderr of the
+                executed command.
+
+        Raises:
+            InterpreterError: If the command execution fails.
+        """
+        try:
+            # Get current Python executable's environment
+            env = os.environ.copy()
+
+            proc = subprocess.Popen(
+                command,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                env=env,
+                shell=True,  # Use shell=True for command execution
+            )
+            # Add timeout to prevent hanging processes
+            stdout, stderr = proc.communicate(timeout=self.execution_timeout)
+
+            return stdout, stderr
+        except Exception as e:
+            raise InterpreterError(f"Error executing command: {e}")