shellsim 0.1.3__tar.gz → 0.1.4__tar.gz

{shellsim-0.1.3 → shellsim-0.1.4}/Cargo.lock

@@ -330,7 +330,7 @@ dependencies = [
 
 [[package]]
 name = "shellsim"
-version = "0.1.3"
+version = "0.1.4"
 dependencies = [
  "base64",
  "crc32fast",

{shellsim-0.1.3 → shellsim-0.1.4}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "shellsim"
-version = "0.1.3"
+version = "0.1.4"
 edition = "2021"
 description = "In-process BusyBox-like environment for RL rollouts and agent tests"
 license = "Apache-2.0"
@@ -58,5 +58,6 @@ python = []
 opt-level = 1
 
 [profile.release]
-opt-level = "s"
-lto = false
+opt-level = "z"
+lto = "fat"
+codegen-units = 1

{shellsim-0.1.3 → shellsim-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shellsim
-Version: 0.1.3
+Version: 0.1.4
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: MacOS :: MacOS X
@@ -53,8 +53,25 @@ The current environment includes:
   third-party module surface.
 
 Python is source-compatible where supported, not ABI-compatible with CPython. Native extensions,
-package installation, compilers, and arbitrary machine code are outside the simulation boundary.
-See [Python in shellsim](docs/python.md) for the current contract.
+network package installation, compilers, and arbitrary machine code are outside the simulation
+boundary. The simulated `pip` and `uv` paths can activate packages already bundled with
+shellsim; they reject other packages instead of fetching them. See
+[Python in shellsim](docs/python.md) for the current contract.
+
+`git` provides a porcelain subset backed by the virtual filesystem: staging, commits, history,
+diffs, branches, tags, merges, stashes, and search, with output that matches real Git where an
+agent is likely to parse it. Networked subcommands and content conflicts are refused rather than
+approximated. See [Git in shellsim](docs/git.md) for the supported surface and its boundaries.
+
+Common utilities accept clustered short options, long options, option values, and `--` through a
+shared parser. Each utility declares its supported options. For example, `grep` supports ordinary
+basic and extended regular expressions, recursive search, fixed strings, word and whole-line
+matching, pattern files, include and exclude filters, context, counts, line numbers, match limits,
+and common output controls. `sed` covers addresses and ranges plus the common substitution,
+selection, text, transliteration, and early-exit commands. `awk` parses a typed language subset
+with record rules, control flow, fields, associative arrays, arithmetic, regular expressions, and
+the usual scalar functions. Unsupported syntax and options exit nonzero with a direct diagnostic;
+text processing is UTF-8-only unless a command documents a byte-oriented mode.
 
 ## Install and run
 
@@ -80,6 +97,8 @@ cargo build --release
 
 Limits accept `k`, `m`, and `g` binary suffixes. `eval` emits a structured result containing the
 exit status, stdout and stderr, resource use, command trace, and unsupported behavior.
+`unsupported_commands` lists recognized or attempted commands that crossed the capability
+boundary; invocation records include trust, status, and the unsupported reason.
 
 The Python API exposes fresh and persistent environments:
 
@@ -93,6 +112,36 @@ assert result.returncode == 0
 assert result.stdout == b"42\n"
 ```
 
+Static HTTP fixtures use the same isolated environment. They do not enable sockets, DNS, TLS, or
+host-network access:
+
+```python
+environment = shellsim.Environment(http={
+    "https://api.test/items/*": shellsim.HttpResponse(
+        status=200,
+        headers={"Content-Type": "application/json"},
+        body='{"items": []}',
+    ),
+})
+result = environment.run("curl -s https://api.test/items/1")
+
+result = environment.run_python("""
+from urllib.request import urlopen
+print(urlopen('https://api.test/items/1').read())
+""")
+assert result.network_requests[0].matched
+```
+
+Python source can bypass shell parsing and quoting while using the same isolated runtime:
+
+```python
+result = shellsim.python.run("print(sum(range(10)))", argv=["example"])
+result.check_returncode()
+
+environment = shellsim.Environment()
+result = environment.run_python("print('persistent VFS, fresh Python interpreter')")
+```
+
 ## Agent harness
 
 `shellsim serve --root ./project` runs a persistent newline-delimited JSON session. It supports

{shellsim-0.1.3 → shellsim-0.1.4}/README.md

@@ -30,8 +30,25 @@ The current environment includes:
   third-party module surface.
 
 Python is source-compatible where supported, not ABI-compatible with CPython. Native extensions,
-package installation, compilers, and arbitrary machine code are outside the simulation boundary.
-See [Python in shellsim](docs/python.md) for the current contract.
+network package installation, compilers, and arbitrary machine code are outside the simulation
+boundary. The simulated `pip` and `uv` paths can activate packages already bundled with
+shellsim; they reject other packages instead of fetching them. See
+[Python in shellsim](docs/python.md) for the current contract.
+
+`git` provides a porcelain subset backed by the virtual filesystem: staging, commits, history,
+diffs, branches, tags, merges, stashes, and search, with output that matches real Git where an
+agent is likely to parse it. Networked subcommands and content conflicts are refused rather than
+approximated. See [Git in shellsim](docs/git.md) for the supported surface and its boundaries.
+
+Common utilities accept clustered short options, long options, option values, and `--` through a
+shared parser. Each utility declares its supported options. For example, `grep` supports ordinary
+basic and extended regular expressions, recursive search, fixed strings, word and whole-line
+matching, pattern files, include and exclude filters, context, counts, line numbers, match limits,
+and common output controls. `sed` covers addresses and ranges plus the common substitution,
+selection, text, transliteration, and early-exit commands. `awk` parses a typed language subset
+with record rules, control flow, fields, associative arrays, arithmetic, regular expressions, and
+the usual scalar functions. Unsupported syntax and options exit nonzero with a direct diagnostic;
+text processing is UTF-8-only unless a command documents a byte-oriented mode.
 
 ## Install and run
 
@@ -57,6 +74,8 @@ cargo build --release
 
 Limits accept `k`, `m`, and `g` binary suffixes. `eval` emits a structured result containing the
 exit status, stdout and stderr, resource use, command trace, and unsupported behavior.
+`unsupported_commands` lists recognized or attempted commands that crossed the capability
+boundary; invocation records include trust, status, and the unsupported reason.
 
 The Python API exposes fresh and persistent environments:
 
@@ -70,6 +89,36 @@ assert result.returncode == 0
 assert result.stdout == b"42\n"
 ```
 
+Static HTTP fixtures use the same isolated environment. They do not enable sockets, DNS, TLS, or
+host-network access:
+
+```python
+environment = shellsim.Environment(http={
+    "https://api.test/items/*": shellsim.HttpResponse(
+        status=200,
+        headers={"Content-Type": "application/json"},
+        body='{"items": []}',
+    ),
+})
+result = environment.run("curl -s https://api.test/items/1")
+
+result = environment.run_python("""
+from urllib.request import urlopen
+print(urlopen('https://api.test/items/1').read())
+""")
+assert result.network_requests[0].matched
+```
+
+Python source can bypass shell parsing and quoting while using the same isolated runtime:
+
+```python
+result = shellsim.python.run("print(sum(range(10)))", argv=["example"])
+result.check_returncode()
+
+environment = shellsim.Environment()
+result = environment.run_python("print('persistent VFS, fresh Python interpreter')")
+```
+
 ## Agent harness
 
 `shellsim serve --root ./project` runs a persistent newline-delimited JSON session. It supports

{shellsim-0.1.3 → shellsim-0.1.4}/pyproject.toml

@@ -44,7 +44,7 @@ locked = true
 strip = true
 
 [tool.pytest.ini_options]
-testpaths = ["python_tests"]
+testpaths = ["tests/python_package", "tests/tooling"]
 
 [tool.marin-style]
 checks = ["ruff-check", "ruff-format"]
@@ -52,8 +52,9 @@ include = [
     "infra/*.py",
     "infra/**/*.py",
     "python/**/*.py",
-    "python_tests/*.py",
-    "python_tests/**/*.py",
+    "tests/python/test_*.py",
+    "tests/python_package/**/*.py",
+    "tests/tooling/**/*.py",
     "tools/*.py",
     "tools/**/*.py",
 ]

{shellsim-0.1.3 → shellsim-0.1.4}/python/native/Cargo.lock

@@ -406,7 +406,7 @@ dependencies = [
 
 [[package]]
 name = "shellsim"
-version = "0.1.3"
+version = "0.1.4"
 dependencies = [
  "base64",
  "crc32fast",
@@ -427,7 +427,7 @@ dependencies = [
 
 [[package]]
 name = "shellsim-python-bindings"
-version = "0.1.3"
+version = "0.1.4"
 dependencies = [
  "pyo3",
  "serde",

{shellsim-0.1.3 → shellsim-0.1.4}/python/native/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "shellsim-python-bindings"
-version = "0.1.3"
+version = "0.1.4"
 edition = "2021"
 description = "Python bindings for shellsim"
 license = "Apache-2.0"
@@ -20,5 +20,6 @@ serde_json = "1"
 shellsim = { path = "../.." }
 
 [profile.release]
-opt-level = "s"
-lto = false
+opt-level = "z"
+lto = "fat"
+codegen-units = 1

{shellsim-0.1.3 → shellsim-0.1.4}/python/native/src/lib.rs

@@ -17,6 +17,7 @@ use pyo3::exceptions::PyException;
 use pyo3::prelude::*;
 use pyo3::types::PyBytes;
 use serde::Serialize;
+use shellsim::net::NetworkRequest;
 use shellsim::{CommandTrust, InvocationEvent, Limits, RunOutcome};
 
 const ACTION_STACK_BYTES: usize = 8 * 1024 * 1024;
@@ -35,10 +36,12 @@ struct RunMetadata {
     dropped_unsupported: u64,
     commands: Vec<String>,
     dropped_commands: u64,
-    noop_commands: Vec<String>,
+    unsupported_commands: Vec<String>,
     partial_commands: Vec<String>,
     invocations: Vec<InvocationEvent>,
     dropped_invocations: u64,
+    network_requests: Vec<NetworkRequest>,
+    dropped_network_requests: u64,
 }
 
 #[derive(Serialize)]
@@ -47,6 +50,17 @@ struct MountMetadata {
     skipped_directories: Vec<String>,
 }
 
+struct MetadataStart {
+    command: usize,
+    dropped_commands: u64,
+    unsupported: usize,
+    dropped_unsupported: u64,
+    invocation: u64,
+    dropped_invocations: u64,
+    network: usize,
+    dropped_network: u64,
+}
+
 /// One persistent simulated machine owned by Python.
 #[pyclass(module = "shellsim._native")]
 struct NativeEnvironment {
@@ -91,6 +105,31 @@ impl NativeEnvironment {
         ))
     }
 
+    /// Execute Python source directly without passing it through the shell parser.
+    fn run_python(
+        &self,
+        py: Python<'_>,
+        source: String,
+        argv: Vec<String>,
+        stdin: Vec<u8>,
+    ) -> PyResult<(String, Py<PyBytes>, Py<PyBytes>)> {
+        let (metadata, stdout, stderr) = py
+            .detach(|| {
+                let mut environment = self.lock_environment()?;
+                on_worker(&mut environment, move |environment| {
+                    Ok(run_python_action(environment, source, argv, stdin))
+                })
+            })
+            .map_err(SimulationError::new_err)?;
+        let metadata = serde_json::to_string(&metadata)
+            .map_err(|error| SimulationError::new_err(error.to_string()))?;
+        Ok((
+            metadata,
+            PyBytes::new(py, &stdout).unbind(),
+            PyBytes::new(py, &stderr).unbind(),
+        ))
+    }
+
     /// Write one byte string into the simulated filesystem.
     fn write_file(&self, py: Python<'_>, path: String, data: Vec<u8>, mode: u32) -> PyResult<()> {
         py.detach(|| {
@@ -139,6 +178,36 @@ impl NativeEnvironment {
         .map_err(SimulationError::new_err)
     }
 
+    /// Register one static response in the simulated HTTP broker.
+    fn route_http(
+        &self,
+        py: Python<'_>,
+        pattern: String,
+        method: Option<String>,
+        status: u16,
+        headers: Vec<(String, String)>,
+        body: Vec<u8>,
+    ) -> PyResult<()> {
+        py.detach(|| {
+            let mut environment = self.lock_environment()?;
+            on_worker(&mut environment, move |environment| {
+                environment
+                    .net
+                    .route(
+                        &pattern,
+                        method.as_deref(),
+                        shellsim::net::HttpResponse {
+                            status,
+                            headers,
+                            body,
+                        },
+                    )
+                    .map_err(|error| error.to_string())
+            })
+        })
+        .map_err(SimulationError::new_err)
+    }
+
     /// Import one explicitly selected trusted host tree into the simulated filesystem.
     fn mount(
         &self,
@@ -188,35 +257,77 @@ fn run_action(
     source: &str,
     stdin: &[u8],
 ) -> (RunMetadata, Vec<u8>, Vec<u8>) {
-    let command_start = environment.cmd_trace.len();
-    let dropped_commands_start = environment.cmd_trace.dropped();
-    let unsupported_start = environment.unsupported.len();
-    let dropped_unsupported_start = environment.unsupported.dropped();
-    let invocation_start = environment.invocations.next_sequence();
-    let dropped_invocations_start = environment.invocations.dropped();
+    let start = metadata_start(environment);
     let (outcome, stdout, stderr) = environment.run_script_capture_with_stdin(source, stdin);
-    let invocations = environment.invocations.events_since(invocation_start);
-    let metadata = RunMetadata {
+    (metadata_finish(environment, outcome, start), stdout, stderr)
+}
+
+fn run_python_action(
+    environment: &mut shellsim::Environment,
+    source: String,
+    arguments: Vec<String>,
+    stdin: Vec<u8>,
+) -> (RunMetadata, Vec<u8>, Vec<u8>) {
+    let start = metadata_start(environment);
+    let mut argv = vec!["python3.14".to_string(), "-c".to_string(), source];
+    argv.extend(arguments);
+    let mut stdout = Vec::new();
+    let mut stderr = Vec::new();
+    let status = shellsim::exec::exec(
+        environment,
+        &shellsim::shell::Node::ArgvCommand(argv),
+        stdin,
+        &mut stdout,
+        &mut stderr,
+    );
+    let outcome = environment.outcome(status);
+    (metadata_finish(environment, outcome, start), stdout, stderr)
+}
+
+fn metadata_start(environment: &shellsim::Environment) -> MetadataStart {
+    MetadataStart {
+        command: environment.cmd_trace.len(),
+        dropped_commands: environment.cmd_trace.dropped(),
+        unsupported: environment.unsupported.len(),
+        dropped_unsupported: environment.unsupported.dropped(),
+        invocation: environment.invocations.next_sequence(),
+        dropped_invocations: environment.invocations.dropped(),
+        network: environment.net.log.len(),
+        dropped_network: environment.net.dropped_requests,
+    }
+}
+
+fn metadata_finish(
+    environment: &shellsim::Environment,
+    outcome: RunOutcome,
+    start: MetadataStart,
+) -> RunMetadata {
+    let invocations = environment.invocations.events_since(start.invocation);
+    RunMetadata {
         outcome,
-        unsupported: environment.unsupported.values_since(unsupported_start),
+        unsupported: environment.unsupported.values_since(start.unsupported),
         dropped_unsupported: environment
             .unsupported
             .dropped()
-            .saturating_sub(dropped_unsupported_start),
-        commands: environment.cmd_trace.values_since(command_start),
+            .saturating_sub(start.dropped_unsupported),
+        commands: environment.cmd_trace.values_since(start.command),
         dropped_commands: environment
             .cmd_trace
             .dropped()
-            .saturating_sub(dropped_commands_start),
-        noop_commands: invocation_names(&invocations, CommandTrust::NoOp),
+            .saturating_sub(start.dropped_commands),
+        unsupported_commands: invocation_names(&invocations, CommandTrust::Unsupported),
         partial_commands: invocation_names(&invocations, CommandTrust::Partial),
         invocations,
         dropped_invocations: environment
             .invocations
             .dropped()
-            .saturating_sub(dropped_invocations_start),
-    };
-    (metadata, stdout, stderr)
+            .saturating_sub(start.dropped_invocations),
+        network_requests: environment.net.log[start.network..].to_vec(),
+        dropped_network_requests: environment
+            .net
+            .dropped_requests
+            .saturating_sub(start.dropped_network),
+    }
 }
 
 fn invocation_names(events: &[InvocationEvent], trust: CommandTrust) -> Vec<String> {

{shellsim-0.1.3 → shellsim-0.1.4}/python/shellsim/__init__.py

@@ -1,8 +1,11 @@
 """Typed Python interface to shellsim's deterministic execution environment."""
 
+from . import python as python
 from ._api import (
     CommandUsage,
     Environment,
+    HttpRequest,
+    HttpResponse,
     Invocation,
     Limits,
     MountResult,
@@ -15,6 +18,8 @@ from ._api import (
 __all__ = [
     "CommandUsage",
     "Environment",
+    "HttpRequest",
+    "HttpResponse",
     "Invocation",
     "Limits",
     "MountResult",
@@ -22,4 +27,5 @@ __all__ = [
     "SimulationError",
     "Usage",
     "run",
+    "python",
 ]

{shellsim-0.1.3 → shellsim-0.1.4}/python/shellsim/_api.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import json
 import os
-from collections.abc import Mapping
+from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
 from typing import Any, Optional, Tuple, Union
 
@@ -64,6 +64,19 @@ class Invocation:
     unsupported_reason: Optional[str] = None
 
 
+@dataclass(frozen=True)
+class HttpRequest:
+    """One bounded request record emitted by the simulated HTTP broker."""
+
+    method: str
+    url: str
+    headers: Tuple[Tuple[str, str], ...]
+    dropped_headers: int
+    body_bytes: int
+    matched: bool
+    response_status: Optional[int]
+
+
 @dataclass(frozen=True)
 class MountResult:
     """Result of copying an explicitly trusted host tree into the VFS."""
@@ -72,6 +85,15 @@ class MountResult:
     skipped_directories: Tuple[str, ...]
 
 
+@dataclass(frozen=True)
+class HttpResponse:
+    """One static response returned by the simulated HTTP broker."""
+
+    status: int = 200
+    headers: Union[Mapping[str, str], Sequence[Tuple[str, str]]] = ()
+    body: Union[bytes, bytearray, memoryview, str] = b""
+
+
 @dataclass(frozen=True)
 class RunResult:
     """Byte-preserving output and structured fidelity/resource telemetry for one action."""
@@ -88,10 +110,12 @@ class RunResult:
     dropped_unsupported: int
     commands: Tuple[str, ...]
     dropped_commands: int
-    noop_commands: Tuple[str, ...]
+    unsupported_commands: Tuple[str, ...]
     partial_commands: Tuple[str, ...]
     invocations: Tuple[Invocation, ...]
     dropped_invocations: int
+    network_requests: Tuple[HttpRequest, ...]
+    dropped_network_requests: int
 
     @property
     def stdout_text(self) -> str:
@@ -129,6 +153,7 @@ class Environment:
         memory: Optional[int] = None,
         disk: Optional[int] = None,
         output: Optional[int] = None,
+        http: Optional[Mapping[str, HttpResponse]] = None,
     ) -> None:
         overrides = {"cpu": cpu, "memory": memory, "disk": disk, "output": output}
         if limits is not None and any(value is not None for value in overrides.values()):
@@ -144,6 +169,11 @@ class Environment:
             resolved.disk,
             resolved.output,
         )
+        if http is not None:
+            if not isinstance(http, Mapping):
+                raise TypeError("http must be a mapping from URL patterns to shellsim.HttpResponse")
+            for pattern, response in http.items():
+                self.route_http(pattern, response)
 
     @property
     def terminated(self) -> bool:
@@ -159,6 +189,32 @@ class Environment:
         metadata, stdout, stderr = self._native.run(source, _as_bytes("stdin", stdin))
         return _decode_result(metadata, stdout, stderr)
 
+    def run_python(
+        self,
+        source: str,
+        argv: Sequence[str] = (),
+        stdin: Union[bytes, bytearray, memoryview] = b"",
+    ) -> RunResult:
+        """Execute Python source directly in this environment.
+
+        The Python interpreter is fresh for each call. The simulated filesystem, cwd, resource
+        usage, and terminal exhaustion state belong to the persistent environment.
+        """
+
+        if not isinstance(source, str):
+            raise TypeError("source must be str")
+        if isinstance(argv, (str, bytes, bytearray, memoryview)) or not isinstance(argv, Sequence):
+            raise TypeError("argv must be a sequence of str")
+        arguments = list(argv)
+        if not all(isinstance(argument, str) for argument in arguments):
+            raise TypeError("argv must be a sequence of str")
+        metadata, stdout, stderr = self._native.run_python(
+            source,
+            arguments,
+            _as_bytes("stdin", stdin),
+        )
+        return _decode_result(metadata, stdout, stderr)
+
     def write_file(
         self,
         path: str,
@@ -196,6 +252,34 @@ class Environment:
             raise TypeError("parents must be bool")
         self._native.mkdir(path, parents)
 
+    def route_http(
+        self,
+        pattern: str,
+        response: HttpResponse,
+        *,
+        method: Optional[str] = None,
+    ) -> None:
+        """Register a static HTTP response for an exact URL or ``*`` glob.
+
+        Requests are handled inside the simulator. This does not grant the environment DNS,
+        sockets, TLS, or access to the host network. When ``method`` is omitted, the route matches
+        every HTTP method.
+        """
+
+        if not isinstance(pattern, str):
+            raise TypeError("pattern must be str")
+        if not isinstance(response, HttpResponse):
+            raise TypeError("response must be a shellsim.HttpResponse instance")
+        if method is not None and not isinstance(method, str):
+            raise TypeError("method must be str or None")
+        if isinstance(response.status, bool) or not isinstance(response.status, int):
+            raise TypeError("response status must be int")
+        if not 0 <= response.status <= 0xFFFF:
+            raise ValueError("response status must fit in an unsigned 16-bit integer")
+        headers = _http_headers(response.headers)
+        body = response.body.encode() if isinstance(response.body, str) else _as_bytes("response body", response.body)
+        self._native.route_http(pattern, method, response.status, headers, body)
+
     def mount(self, host_root: Union[str, os.PathLike[str]], destination: str = "/work") -> MountResult:
         """Copy an explicitly trusted host directory into the bounded VFS.
 
@@ -225,6 +309,7 @@ def run(
     memory: Optional[int] = None,
     disk: Optional[int] = None,
     output: Optional[int] = None,
+    http: Optional[Mapping[str, HttpResponse]] = None,
 ) -> RunResult:
     """Execute one action in a fresh environment."""
 
@@ -234,6 +319,7 @@ def run(
         memory=memory,
         disk=disk,
         output=output,
+        http=http,
     ).run(source, stdin)
 
 
@@ -251,6 +337,24 @@ def _as_bytes(name: str, value: Any) -> bytes:
     return bytes(value)
 
 
+def _http_headers(value: Any) -> list[Tuple[str, str]]:
+    if isinstance(value, Mapping):
+        headers = list(value.items())
+    elif isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray, memoryview)):
+        headers = list(value)
+    else:
+        raise TypeError("response headers must be a mapping or sequence of name/value pairs")
+    normalized = []
+    for header in headers:
+        if not isinstance(header, Sequence) or isinstance(header, (str, bytes)) or len(header) != 2:
+            raise TypeError("response headers must contain name/value pairs")
+        name, item = header
+        if not isinstance(name, str) or not isinstance(item, str):
+            raise TypeError("response header names and values must be str")
+        normalized.append((name, item))
+    return normalized
+
+
 def _decode_result(metadata_json: str, stdout: bytes, stderr: bytes) -> RunResult:
     metadata: Mapping[str, Any] = json.loads(metadata_json)
     outcome = metadata["outcome"]
@@ -270,6 +374,18 @@ def _decode_result(metadata_json: str, stdout: bytes, stderr: bytes) -> RunResul
         )
         for item in metadata["invocations"]
     )
+    network_requests = tuple(
+        HttpRequest(
+            method=item["method"],
+            url=item["url"],
+            headers=tuple(tuple(header) for header in item["headers"]),
+            dropped_headers=item["dropped_headers"],
+            body_bytes=item["body_bytes"],
+            matched=item["matched"],
+            response_status=item["response_status"],
+        )
+        for item in metadata["network_requests"]
+    )
     return RunResult(
         returncode=outcome["exit_status"],
         stdout=stdout,
@@ -283,8 +399,10 @@ def _decode_result(metadata_json: str, stdout: bytes, stderr: bytes) -> RunResul
         dropped_unsupported=metadata["dropped_unsupported"],
         commands=tuple(metadata["commands"]),
         dropped_commands=metadata["dropped_commands"],
-        noop_commands=tuple(metadata["noop_commands"]),
+        unsupported_commands=tuple(metadata["unsupported_commands"]),
         partial_commands=tuple(metadata["partial_commands"]),
         invocations=invocations,
         dropped_invocations=metadata["dropped_invocations"],
+        network_requests=network_requests,
+        dropped_network_requests=metadata["dropped_network_requests"],
     )