fix: microsand box integration (#3101)

Wendong-Fan · web-flow · commit 9b6032027658 · 2025-09-06T23:10:10.000+08:00
diff --git a/camel/interpreters/microsandbox_interpreter.py b/camel/interpreters/microsandbox_interpreter.py
@@ -12,7 +12,6 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import asyncio
-import shlex
 from typing import Any, ClassVar, Dict, List, Optional, Tuple, Union
 
 from camel.interpreters.base import BaseInterpreter
@@ -54,7 +53,7 @@ class MicrosandboxInterpreter(BaseInterpreter):
 
     Note:
         The SDK handles parameter priority as: user parameter > environment
-        variable > default value.
+            variable > default value.
     """
 
     _CODE_TYPE_MAPPING: ClassVar[Dict[str, str]] = {
@@ -84,15 +83,10 @@ def __init__(
         sandbox_name: Optional[str] = None,
         timeout: int = 30,
     ) -> None:
-        try:
-            from microsandbox import (  # type: ignore[import-not-found,import-untyped]
-                NodeSandbox,
-                PythonSandbox,
-            )
-        except ImportError as e:
-            raise ImportError(
-                "Please install microsandbox to use MicrosandboxInterpreter"
-            ) from e
+        from microsandbox import (
+            NodeSandbox,
+            PythonSandbox,
+        )
 
         # Store parameters, let SDK handle defaults and environment variables
         self.require_confirm = require_confirm
@@ -205,7 +199,9 @@ async def _run_python_code(self, code: str) -> str:
         async with self._PythonSandbox.create(
             **self._sandbox_config
         ) as sandbox:
-            execution = await sandbox.run(code)
+            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:
@@ -218,7 +214,9 @@ async def _run_node_code(self, code: str) -> str:
             str: Execution output.
         """
         async with self._NodeSandbox.create(**self._sandbox_config) as sandbox:
-            execution = await sandbox.run(code)
+            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:
@@ -234,7 +232,9 @@ async def _run_shell_command(self, code: str) -> str:
         async with self._PythonSandbox.create(
             **self._sandbox_config
         ) as sandbox:
-            execution = await sandbox.command.run("bash", ["-c", code])
+            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:
@@ -372,24 +372,13 @@ async def _execute_command_async(self, command: str) -> str:
             InterpreterError: If execution fails.
         """
         try:
-            # Parse the command string into command and arguments
-            try:
-                command_parts = shlex.split(command)
-                if not command_parts:
-                    raise InterpreterError("Empty command")
-
-                cmd = command_parts[0]
-                args = command_parts[1:] if len(command_parts) > 1 else []
-            except ValueError as e:
-                raise InterpreterError(f"Invalid command format: {e}")
-
-            # Create and use sandbox with context manager
             async with self._PythonSandbox.create(
                 **self._sandbox_config
             ) as sandbox:
-                # Use the command interface with proper command and args format
-                execution = await sandbox.command.run(cmd, args)
-
+                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:
diff --git a/camel/runtimes/daytona_runtime.py b/camel/runtimes/daytona_runtime.py
@@ -16,7 +16,7 @@
 import json
 import os
 from functools import wraps
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Union
 
 from pydantic import BaseModel
 
@@ -49,15 +49,15 @@ def __init__(
         api_url: Optional[str] = None,
         language: Optional[str] = "python",
     ):
-        from daytona_sdk import Daytona, DaytonaConfig
+        from daytona_sdk import Daytona, DaytonaConfig, Sandbox
 
         super().__init__()
         self.api_key = api_key or os.environ.get('DAYTONA_API_KEY')
         self.api_url = api_url or os.environ.get('DAYTONA_API_URL')
         self.language = language
         self.config = DaytonaConfig(api_key=self.api_key, api_url=self.api_url)
         self.daytona = Daytona(self.config)
-        self.sandbox = None
+        self.sandbox: Optional[Sandbox] = None
         self.entrypoint: Dict[str, str] = dict()
 
     def build(self) -> "DaytonaRuntime":
@@ -66,10 +66,10 @@ def build(self) -> "DaytonaRuntime":
         Returns:
             DaytonaRuntime: The current runtime.
         """
-        from daytona_sdk import CreateSandboxParams
+        from daytona_sdk import CreateSandboxBaseParams
 
         try:
-            params = CreateSandboxParams(language=self.language)
+            params = CreateSandboxBaseParams(language=self.language)
             self.sandbox = self.daytona.create(params)
             if self.sandbox is None:
                 raise RuntimeError("Failed to create sandbox.")
@@ -83,7 +83,7 @@ def _cleanup(self):
         r"""Clean up the sandbox when exiting."""
         if self.sandbox:
             try:
-                self.daytona.remove(self.sandbox)
+                self.daytona.delete(self.sandbox)
                 logger.info(f"Sandbox {self.sandbox.id} removed")
                 self.sandbox = None
             except Exception as e:
@@ -112,7 +112,7 @@ def add(
         if arguments is not None:
             entrypoint += json.dumps(arguments, ensure_ascii=False)
 
-        def make_wrapper(inner_func, func_name, func_code):
+        def make_wrapper(inner_func: Callable, func_name: str, func_code: str):
             r"""Creates a wrapper for a function to execute it in the
             Daytona sandbox.
 
@@ -208,12 +208,11 @@ def info(self) -> str:
             RuntimeError: If the sandbox is not initialized.
         """
         if self.sandbox is None:
-            raise RuntimeError("Failed to create sandbox.")
-        info = self.sandbox.info()
+            raise RuntimeError("Sandbox not initialized.")
         return (
-            f"Sandbox {info.name}:\n"
-            f"State: {info.state}\n"
-            f"Resources: {info.resources.cpu} CPU, {info.resources.memory} RAM"
+            f"Sandbox {self.sandbox.id}:\n"
+            f"State: {self.sandbox.state}\n"
+            f"Resources: {self.sandbox.cpu} CPU, {self.sandbox.memory} RAM"
         )
 
     def __del__(self):
diff --git a/camel/toolkits/video_analysis_toolkit.py b/camel/toolkits/video_analysis_toolkit.py
@@ -195,18 +195,24 @@ def __del__(self):
         destroyed.
         """
         # Clean up temporary files
-        for temp_file in self._temp_files:
-            if os.path.exists(temp_file):
-                try:
-                    os.remove(temp_file)
-                    logger.debug(f"Removed temporary file: {temp_file}")
-                except OSError as e:
-                    logger.warning(
-                        f"Failed to remove temporary file {temp_file}: {e}"
-                    )
+        if hasattr(self, '_temp_files'):
+            for temp_file in self._temp_files:
+                if os.path.exists(temp_file):
+                    try:
+                        os.remove(temp_file)
+                        logger.debug(f"Removed temporary file: {temp_file}")
+                    except OSError as e:
+                        logger.warning(
+                            f"Failed to remove temporary file {temp_file}: {e}"
+                        )
 
         # Clean up temporary directory if needed
-        if self._cleanup and os.path.exists(self._working_directory):
+        if (
+            hasattr(self, '_cleanup')
+            and self._cleanup
+            and hasattr(self, '_working_directory')
+            and os.path.exists(self._working_directory)
+        ):
             try:
                 import sys
 
diff --git a/pyproject.toml b/pyproject.toml
@@ -171,12 +171,12 @@ dev_tools = [
     "ipykernel>=6.0.0,<7",
     "agentops>=0.3.21,<0.4",
     "e2b-code-interpreter>=1.0.3,<2",
-    "microsandbox>=0.1.0",
+    "microsandbox>=0.1.8",
     "tree-sitter-python>=0.23.6,<0.24",
     "tree-sitter>=0.23.2,<0.24",
     "typer>=0.15.2",
     "mcp>=1.3.0",
-    "daytona-sdk==0.20.0",
+    "daytona-sdk>=0.20.0",
     "aci-sdk>=1.0.0b1",
     "langfuse>=2.60.5",
 ]
@@ -251,7 +251,6 @@ owl = [
     "requests_oauthlib>=1.3.1,<2",
     "websockets>=13.0,<15.1",
     "e2b-code-interpreter>=1.0.3,<2",
-    "microsandbox>=0.1.0",
     "typer>=0.15.2",
     "tree-sitter-python>=0.23.6,<0.24",
     "tree-sitter>=0.23.2,<0.24",
@@ -329,7 +328,7 @@ all = [
     "rouge>=1.0.1,<2",
     "aiosqlite>=0.20.0,<0.21",
     "e2b-code-interpreter>=1.0.3,<2",
-    "microsandbox>=0.1.0",
+    "microsandbox>=0.1.8",
     "firecrawl-py>=1.0.0,<2",
     "arxiv>=2.1.3,<3",
     "arxiv2text>=0.1.14,<0.2",
@@ -408,7 +407,7 @@ all = [
     "pyautogui>=0.9.54,<0.10",
     "pyobvector>=0.1.18",
     "scrapegraph-py>=1.12.0,<2",
-    "daytona-sdk==0.20.0",
+    "daytona-sdk>=0.20.0",
     "ibm-watsonx-ai>=1.3.11",
     "google-genai>=1.13.0",
     "aci-sdk>=1.0.0b1",
@@ -656,6 +655,7 @@ module = [
     "pgvector.*",
     "reportlab.*",
     "surrealdb.*",
+    "microsandbox.*"
 ]
 ignore_missing_imports = true
 
diff --git a/uv.lock b/uv.lock
