verifiers 0.2.2.dev36__tar.gz → 0.2.2.dev38__tar.gz

{verifiers-0.2.2.dev36 → verifiers-0.2.2.dev38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: verifiers
-Version: 0.2.2.dev36
+Version: 0.2.2.dev38
 Summary: Verifiers: Environments for LLM Reinforcement Learning
 Project-URL: Homepage, https://github.com/primeintellect-ai/verifiers
 Project-URL: Documentation, https://github.com/primeintellect-ai/verifiers

{verifiers-0.2.2.dev36 → verifiers-0.2.2.dev38}/verifiers/v1/runtimes/base.py

@@ -13,7 +13,7 @@ from dataclasses import dataclass
 from pathlib import PurePosixPath
 from typing import ClassVar, Self
 
-from pydantic import Field
+from pydantic import Field, model_validator
 from pydantic_config import BaseConfig
 
 from verifiers.v1.errors import SandboxError
@@ -100,15 +100,32 @@ class NetworkPolicyConfig(BaseConfig):
     """Shared execution-time policy surface for runtimes that support it."""
 
     allow: list[str] = Field(default_factory=lambda: ["*"])
-    """Destinations allowed during execution; `*` leaves egress unrestricted."""
+    """Destinations allowed during execution; `*` is unrestricted and `[]` is
+    framework-only."""
     block: list[str] = Field(default_factory=list)
-    """Destinations denied during execution."""
+    """Destinations denied during execution; any `*` makes the policy framework-only."""
+
+    @model_validator(mode="after")
+    def _validate_network_policy(self) -> Self:
+        if not self.allow or "*" in self.block:
+            # Empty allowlists and wildcard blocks both mean framework-only access.
+            self.allow = []
+            self.block = ["*"]
+        elif self.allow != ["*"] and self.block:
+            raise ValueError(
+                "non-empty concrete allow and block egress lists are mutually exclusive"
+            )
+        return self
 
     @property
     def network_restricted(self) -> bool:
         return "*" not in self.allow or bool(self.block)
 
     def with_task_network_policy(self, allow: list[str], block: list[str]) -> Self:
+        values = self.model_dump()
+        if not allow or not self.allow or "*" in block:
+            # Framework-only access is absorbing; composition cannot widen either side.
+            return type(self).model_validate({**values, "allow": [], "block": ["*"]})
         if "*" not in allow:
             allow = (
                 allow
@@ -118,9 +135,7 @@ class NetworkPolicyConfig(BaseConfig):
         else:
             allow = self.allow
         block = list(dict.fromkeys([*block, *self.block]))
-        return type(self).model_validate(
-            {**self.model_dump(), "allow": allow, "block": block}
-        )
+        return type(self).model_validate({**values, "allow": allow, "block": block})
 
 
 class BaseRuntimeInfo(BaseConfig):
@@ -285,7 +300,7 @@ class Runtime(ABC):
 
     async def prepare_execution(self, routes: list[str]) -> None:
         """Last setup step, right before the agent starts. Restricted runtimes enforce
-        their policy here while keeping the interception and MCP `routes` reachable."""
+        their policy here; `routes` identifies the interception and MCP endpoints."""
 
     @property
     def network_restricted(self) -> bool:

{verifiers-0.2.2.dev36 → verifiers-0.2.2.dev38}/verifiers/v1/runtimes/prime.py

@@ -16,6 +16,7 @@ from pathlib import Path, PurePosixPath
 from typing import ClassVar, Literal
 from urllib.parse import urlsplit
 
+from prime_sandboxes.models import validate_egress_lists
 from pydantic import Field, model_validator
 
 from verifiers.v1.errors import SandboxError
@@ -75,12 +76,12 @@ class PrimeConfig(NetworkPolicyConfig):
             raise ValueError(
                 "Prime allow/block egress lists require a VM sandbox (vm=true)"
             )
-        from prime_sandboxes.models import validate_egress_lists
-
-        allow = None if self.allow == ["*"] else self.allow
-        block = self.block or None
-        if allow is not None or block != ["*"]:
-            validate_egress_lists(allow, block)
+        if not self.allow:
+            return self
+        validate_egress_lists(
+            None if self.allow == ["*"] else self.allow,
+            self.block or None,
+        )
         return self
 
     @model_validator(mode="after")
@@ -185,13 +186,15 @@ class PrimeRuntime(Runtime):
         if not self.network_restricted:
             return
         try:
+            hosts = list(
+                dict.fromkeys(
+                    h for h in (urlsplit(route).hostname for route in routes) if h
+                )
+            )
             if self.config.allow == ["*"]:
                 policy = {"deny": self.config.block}
             else:
-                hosts = [h for h in (urlsplit(route).hostname for route in routes) if h]
                 entries = list(dict.fromkeys([*hosts, *self.config.allow]))
-                from prime_sandboxes.models import validate_egress_lists
-
                 validate_egress_lists(entries, None)
                 policy = {"allow": entries} if entries else {"deny": ["*"]}
             status = await self._client.set_network(self.info.id, **policy)

{verifiers-0.2.2.dev36 → verifiers-0.2.2.dev38}/verifiers/v1/task.py

@@ -120,7 +120,8 @@ class TaskData(StrictBaseModel):
     entries. Prime runtimes accept host-level entries and require `vm=true`."""
     network_block: list[str] = Field(default_factory=list)
     """Execution-time destinations denied by this task and combined with runtime
-    blocks. Prime runtimes cannot combine an allowlist and a blocklist."""
+    blocks. Non-empty concrete allowlists cannot be combined with blocklists. Docker
+    framework routes take precedence; ordinary Prime deny rules pass through unchanged."""
     timeout: TaskTimeout = TaskTimeout()
     resources: TaskResources = TaskResources()