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

camel/toolkits/code_execution.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. =========
 from typing import List, Literal, Optional, Union
 
 from camel.interpreters import (
@@ -18,12 +18,16 @@ from camel.interpreters import (
     E2BInterpreter,
     InternalPythonInterpreter,
     JupyterKernelInterpreter,
+    MicrosandboxInterpreter,
     SubprocessInterpreter,
 )
+from camel.logger import get_logger
 from camel.toolkits import FunctionTool
 from camel.toolkits.base import BaseToolkit
 from camel.utils import MCPServer
 
+logger = get_logger(__name__)
+
 
 @MCPServer()
 class CodeExecutionToolkit(BaseToolkit):
@@ -36,22 +40,35 @@ class CodeExecutionToolkit(BaseToolkit):
             (default: :obj:`False`)
         unsafe_mode (bool):  If `True`, the interpreter runs the code
             by `eval()` without any security check. (default: :obj:`False`)
-        import_white_list ( Optional[List[str]]): A list of allowed imports.
+        import_white_list (Optional[List[str]]): A list of allowed imports.
             (default: :obj:`None`)
-        require_confirm (bool): Whether to require confirmation before executing code.
-            (default: :obj:`False`)
+        require_confirm (bool): Whether to require confirmation before
+            executing code. (default: :obj:`False`)
+        timeout (Optional[float]): General timeout for toolkit operations.
+            (default: :obj:`None`)
+        microsandbox_config (Optional[dict]): Configuration for microsandbox
+            interpreter. Available keys: 'server_url', 'api_key',
+            'namespace', 'sandbox_name', 'timeout'.
+            If None, uses default configuration. (default: :obj:`None`)
     """
 
     def __init__(
         self,
         sandbox: Literal[
-            "internal_python", "jupyter", "docker", "subprocess", "e2b"
+            "internal_python",
+            "jupyter",
+            "docker",
+            "subprocess",
+            "e2b",
+            "microsandbox",
         ] = "subprocess",
         verbose: bool = False,
         unsafe_mode: bool = False,
         import_white_list: Optional[List[str]] = None,
         require_confirm: bool = False,
         timeout: Optional[float] = None,
+        # Microsandbox configuration dictionary
+        microsandbox_config: Optional[dict] = None,
     ) -> None:
         super().__init__(timeout=timeout)
         self.verbose = verbose
@@ -65,6 +82,7 @@ class CodeExecutionToolkit(BaseToolkit):
             DockerInterpreter,
             SubprocessInterpreter,
             E2BInterpreter,
+            MicrosandboxInterpreter,
         ]
 
         if sandbox == "internal_python":
@@ -92,23 +110,58 @@ class CodeExecutionToolkit(BaseToolkit):
             )
         elif sandbox == "e2b":
             self.interpreter = E2BInterpreter(require_confirm=require_confirm)
+        elif sandbox == "microsandbox":
+            # Extract parameters with proper types for microsandbox
+            config = microsandbox_config or {}
+
+            self.interpreter = MicrosandboxInterpreter(
+                require_confirm=require_confirm,
+                server_url=config.get("server_url"),
+                api_key=config.get("api_key"),
+                namespace=config.get("namespace", "default"),
+                sandbox_name=config.get("sandbox_name"),
+                timeout=config.get("timeout", 30),
+            )
         else:
             raise RuntimeError(
                 f"The sandbox type `{sandbox}` is not supported."
             )
 
-    def execute_code(self, code: str) -> str:
+    def execute_code(self, code: str, code_type: str = "python") -> str:
         r"""Execute a given code snippet.
 
         Args:
             code (str): The input code to the Code Interpreter tool call.
+            code_type (str): The type of the code to be executed
+                (e.g. node.js, python, etc). (default: obj:`python`)
 
         Returns:
             str: The text output from the Code Interpreter tool call.
         """
-        output = self.interpreter.run(code, "python")
-        # ruff: noqa: E501
-        content = f"Executed the code below:\n```py\n{code}\n```\n> Executed Results:\n{output}"
+        output = self.interpreter.run(code, code_type)
+        content = (
+            f"Executed the code below:\n```{code_type}\n{code}\n```\n"
+            f"> Executed Results:\n{output}"
+        )
+        if self.verbose:
+            print(content)
+        return content
+
+    def execute_command(self, command: str) -> Union[str, tuple[str, str]]:
+        r"""Execute a command can be used to resolve the dependency of the
+        code. Useful if there's dependency issues when you try to execute code.
+
+        Args:
+            command (str): The command to execute.
+
+        Returns:
+            Union[str, tuple[str, str]]: The output of the command.
+        """
+        output = self.interpreter.execute_command(command)
+        content = (
+            f"Executed the command below:\n```sh\n{command}\n```\n"
+            f"> Executed Results:\n{output}"
+        )
         if self.verbose:
             print(content)
         return content
@@ -121,4 +174,7 @@ class CodeExecutionToolkit(BaseToolkit):
             List[FunctionTool]: A list of FunctionTool objects
                 representing the functions in the toolkit.
         """
-        return [FunctionTool(self.execute_code)]
+        return [
+            FunctionTool(self.execute_code),
+            FunctionTool(self.execute_command),
+        ]