inspect-sandboxes 0.1.1.dev1__tar.gz → 0.1.2__tar.gz

{inspect_sandboxes-0.1.1.dev1 → inspect_sandboxes-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inspect_sandboxes
-Version: 0.1.1.dev1
+Version: 0.1.2
 Summary: Collection of sandboxes for Inspect AI
 Project-URL: Source Code, https://github.com/meridianlabs-ai/inspect_sandboxes
 Project-URL: Issue Tracker, https://github.com/meridianlabs-ai/inspect_sandboxes/issues

{inspect_sandboxes-0.1.1.dev1 → inspect_sandboxes-0.1.2}/src/inspect_sandboxes/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.1.1.dev1'
-__version_tuple__ = version_tuple = (0, 1, 1, 'dev1')
+__version__ = version = '0.1.2'
+__version_tuple__ = version_tuple = (0, 1, 2)
 
 __commit_id__ = commit_id = None

{inspect_sandboxes-0.1.1.dev1 → inspect_sandboxes-0.1.2}/src/inspect_sandboxes/daytona/README.md

@@ -88,5 +88,13 @@ task = Task(
 ## Notes
 
 - **stderr**: The Daytona API returns a single combined output; `stderr` is always empty and all output appears in `stdout`.
-- **stdin**: The `input` parameter to `exec()` is not supported and will be ignored with a warning.
+- **stdin**: The `input` parameter to `exec()` is supported by uploading a temp file and piping it into the command.
 - **user**: The `user` parameter to `exec()` is not supported; use `os_user` in `x-daytona` to set the OS user.
+- **network_mode**: Docker Compose `network_mode` is automatically translated to Daytona's `network_block_all` parameter. `network_mode: none` blocks all network access; any other value (e.g. `bridge`) allows it. The `x-daytona` extension `network_block_all` takes precedence if set.
+
+## Known Limitations
+
+- **Architecture**: Daytona runners use `linux/amd64`. Tasks with arm64-only base images cannot run on Daytona. The image publisher must add amd64 support.
+- **Resource limits**: Daytona enforces per-sandbox limits. Tasks requesting more will fail with `CPU request N exceeds maximum` or `Memory request exceeds maximum`. Use `override_cpus` / `override_memory_mb` task args to cap resources, or contact Daytona support for higher limits.
+- **Single service**: Only one service is supported per sandbox. Multi-service compose files are not supported.
+- **Internet access**: Outbound internet access from sandboxes depends on your Daytona billing tier. Lower tiers (Tier 1–2) have restricted network access that cannot be overridden by the `network_block_all` parameter. If tasks fail with `curl: (35) Recv failure: Connection reset by peer` or similar network errors despite `network_block_all: false`, upgrade to a higher tier (Tier 3+) for full outbound internet access.

{inspect_sandboxes-0.1.1.dev1 → inspect_sandboxes-0.1.2}/src/inspect_sandboxes/daytona/_compose.py

@@ -57,6 +57,11 @@ def convert_compose_to_daytona_params(
     if service.user:
         sandbox_params["os_user"] = service.user
 
+    # Translate Docker network_mode to Daytona network_block_all.
+    # Only set as a default; x-daytona extensions can override below.
+    if service.network_mode is not None and "network_block_all" not in sandbox_params:
+        sandbox_params["network_block_all"] = service.network_mode == "none"
+
     _apply_daytona_extensions(sandbox_params, config.extensions)
 
     return image, resources, sandbox_params

{inspect_sandboxes-0.1.1.dev1 → inspect_sandboxes-0.1.2}/src/inspect_sandboxes/daytona/_daytona.py

@@ -4,6 +4,7 @@ import errno
 import os
 import shlex
 import sys
+import uuid
 from contextvars import ContextVar
 from logging import getLogger
 from pathlib import PurePosixPath
@@ -306,14 +307,18 @@ class DaytonaSandboxEnvironment(SandboxEnvironment):
                 "Commands will run as the container's default user.",
             )
 
+        # Daytona's process.exec() doesn't support stdin natively.
+        # When input is provided, write it to a temp file and pipe it into the command.
         if input is not None:
-            warn_once(
-                logger,
-                "The 'input' (stdin) parameter is not supported in DaytonaSandboxEnvironment "
-                "and will be ignored.",
+            data = input.encode("utf-8") if isinstance(input, str) else input
+            stdin_file = f"/tmp/.inspect-stdin-{uuid.uuid4().hex}"
+            await self.sandbox.fs.upload_file(data, stdin_file)
+            command = (
+                f"set -o pipefail; cat {shlex.quote(stdin_file)} | {shlex.join(cmd)}"
+                f"; _ec=$?; rm -f {shlex.quote(stdin_file)}; exit $_ec"
             )
-
-        command = shlex.join(cmd)
+        else:
+            command = shlex.join(cmd)
 
         async def _run(t: int | None) -> ExecResult[str]:
             response = await self.sandbox.process.exec(

{inspect_sandboxes-0.1.1.dev1 → inspect_sandboxes-0.1.2}/src/inspect_sandboxes/modal/README.md

@@ -81,6 +81,14 @@ task = Task(
 )
 ```
 
+## Notes
+
+- **network_mode**: Docker Compose `network_mode` is automatically translated to Modal's `block_network` parameter. `network_mode: none` blocks all network access; any other value (e.g. `bridge`) allows it. The `x-modal` extension `block_network` takes precedence if set.
+
+## Known Limitations
+
+- **Single service**: Only one compose service is supported per sandbox. Multi-service compose files will raise a `ValueError`.
+
 ## Credits
 
 Based on [@anthonyduong9](https://github.com/anthonyduong9)'s work.

{inspect_sandboxes-0.1.1.dev1 → inspect_sandboxes-0.1.2}/src/inspect_sandboxes/modal/_compose.py

@@ -1,3 +1,5 @@
+import shlex
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 
@@ -11,9 +13,22 @@ from inspect_sandboxes._util.compose import (
 )
 
 
+@dataclass
+class ModalSandboxParams:
+    """Parameters for modal.Sandbox.create().
+
+    Attributes:
+        command: Positional command args passed before **kwargs to Sandbox.create().
+        kwargs: Keyword arguments passed to Sandbox.create().
+    """
+
+    command: list[str] = field(default_factory=list)
+    kwargs: dict[str, Any] = field(default_factory=dict)
+
+
 def convert_compose_to_modal_params(
     config: ComposeConfig, compose_path: str | None
-) -> dict[str, Any]:
+) -> ModalSandboxParams:
     """Convert a ComposeConfig to Modal Sandbox.create() parameters.
 
     Args:
@@ -27,6 +42,7 @@ def convert_compose_to_modal_params(
         service = config.services.get("default") or next(iter(config.services.values()))
 
     params: dict[str, Any] = {}
+    command: list[str] = []
     compose_dir = Path(compose_path).parent if compose_path else Path.cwd()
 
     if service.build:
@@ -40,6 +56,13 @@ def convert_compose_to_modal_params(
     elif service.image:
         params["image"] = modal.Image.from_registry(service.image)
 
+    if service.command:
+        command = (
+            service.command
+            if isinstance(service.command, list)
+            else shlex.split(service.command)
+        )
+
     if service.working_dir:
         params["workdir"] = service.working_dir
 
@@ -58,9 +81,14 @@ def convert_compose_to_modal_params(
     if gpu is not None:
         params["gpu"] = gpu
 
+    # Translate Docker network_mode to Modal block_network.
+    # Only set as a default; x-modal extensions can override below.
+    if service.network_mode is not None:
+        params["block_network"] = service.network_mode == "none"
+
     _apply_modal_extensions(params, config.extensions)
 
-    return params
+    return ModalSandboxParams(command=command, kwargs=params)
 
 
 def _apply_modal_extensions(params: dict[str, Any], extensions: dict[str, Any]) -> None:

{inspect_sandboxes-0.1.1.dev1 → inspect_sandboxes-0.1.2}/src/inspect_sandboxes/modal/_modal.py

@@ -102,24 +102,27 @@ class ModalSandboxEnvironment(SandboxEnvironment):
     ) -> dict[str, SandboxEnvironment]:
         app = await cls._lookup_app(MODAL_APP_NAME)
 
-        sandbox_params: dict[str, Any] = {
+        sandbox_kwargs: dict[str, Any] = {
             "app": app,
             "timeout": 60 * 60 * 24,
         }
+        command: list[str] = []
 
         if config is None:
             trace_message(
                 logger, "modal", f"Using default Modal image for task '{task_name}'"
             )
         elif is_dockerfile(config):
-            sandbox_params["image"] = modal.Image.from_dockerfile(config)
+            sandbox_kwargs["image"] = modal.Image.from_dockerfile(config)
         elif is_compose_yaml(config):
             compose_config = parse_compose_yaml(config, multiple_services=False)
             modal_params = convert_compose_to_modal_params(compose_config, config)
-            sandbox_params.update(modal_params)
+            command = modal_params.command
+            sandbox_kwargs.update(modal_params.kwargs)
         elif isinstance(config, ComposeConfig):
             modal_params = convert_compose_to_modal_params(config, None)
-            sandbox_params.update(modal_params)
+            command = modal_params.command
+            sandbox_kwargs.update(modal_params.kwargs)
         else:
             raise ValueError(
                 f"Unrecognized config: {config}. "
@@ -127,7 +130,7 @@ class ModalSandboxEnvironment(SandboxEnvironment):
                 "ComposeConfig object, or None."
             )
 
-        sandbox = await cls._create_sandbox(sandbox_params)
+        sandbox = await cls._create_sandbox(command, sandbox_kwargs)
         await sandbox.set_tags.aio(INSPECT_SANDBOX_TAG)
         running_sandboxes().append(sandbox.object_id)
 
@@ -421,8 +424,10 @@ class ModalSandboxEnvironment(SandboxEnvironment):
 
     @staticmethod
     @_standard_retry
-    async def _create_sandbox(sandbox_params: dict[str, Any]) -> modal.Sandbox:
-        return await modal.Sandbox.create.aio(**sandbox_params)
+    async def _create_sandbox(
+        command: list[str], kwargs: dict[str, Any]
+    ) -> modal.Sandbox:
+        return await modal.Sandbox.create.aio(*command, **kwargs)
 
     @staticmethod
     @_standard_retry