verifiers 0.3.2.dev108__tar.gz → 0.3.2.dev110__tar.gz

{verifiers-0.3.2.dev108 → verifiers-0.3.2.dev110}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifiers
-Version: 0.3.2.dev108
+Version: 0.3.2.dev110
 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
@@ -36,7 +36,7 @@ Requires-Dist: numpy>=2.1.0
 Requires-Dist: openai<3.0.0,>=2.54.0
 Requires-Dist: prime-pydantic-config[toml]>=0.4.3
 Requires-Dist: prime-runs>=0.1.3
-Requires-Dist: prime-sandboxes>=0.2.39
+Requires-Dist: prime-sandboxes>=0.3.0
 Requires-Dist: prime-tunnel>=0.1.8
 Requires-Dist: pydantic>=2.12.3
 Requires-Dist: pyzmq>=27.1.0

{verifiers-0.3.2.dev108 → verifiers-0.3.2.dev110}/pyproject.toml

@@ -33,7 +33,7 @@ dependencies = [
     "math-verify>=0.8.0",
     "openai>=2.54.0,<3.0.0",
     "prime-tunnel>=0.1.8",
-    "prime-sandboxes>=0.2.39",
+    "prime-sandboxes>=0.3.0",
     "prime-runs>=0.1.3",
     "pydantic>=2.12.3",
     "rich>=11.0.0",

{verifiers-0.3.2.dev108 → verifiers-0.3.2.dev110}/tests/v1/test_e2e.py

@@ -356,10 +356,7 @@ async def test_acp_resume_with_tool(run_v1, harness, harness_runtime, tmp_path):
     (trace,) = await run_v1(
         "echo-acp-resume-v1",
         harness=harness,
-        runtime={
-            "type": harness_runtime,
-            **({"vm": True} if harness_runtime == "prime" else {}),
-        },
+        runtime={"type": harness_runtime},
         output_dir=tmp_path,
         max_turns=8,
         max_tokens=8192,

{verifiers-0.3.2.dev108 → verifiers-0.3.2.dev110}/tests/v1/test_judges.py

@@ -242,7 +242,7 @@ async def test_reference_score(fake_judge_model):
     assert len(trace.info["judge_calls"]) == 1  # the call is recorded onto the trace
     judge_record = trace.info["judge_calls"][0]
     assert judge_record["name"] == "reference"
-    assert judge_record["request"]["model"] == "openai/gpt-5.4-nano"
+    assert judge_record["request"]["model"] == "openai/gpt-5.6-luna"
     assert "Capital of France?" in judge_record["request"]["messages"][0]["content"]
     assert judge_record["response"]["message"] == {
         "role": "assistant",

{verifiers-0.3.2.dev108 → verifiers-0.3.2.dev110}/verifiers/v1/configs/judge.py

@@ -17,7 +17,7 @@ class JudgeConfig(BaseClientConfig):
     name: str = ""
     """Reward key override for a plugged judge."""
     weight: FiniteFloat = 1.0
-    model: str = "openai/gpt-5.4-nano"
+    model: str = "openai/gpt-5.6-luna"
     sampling: SamplingConfig = SamplingConfig()
     prompt: Path | None = None
     """File whose text overrides the judge's default prompt template."""

{verifiers-0.3.2.dev108 → verifiers-0.3.2.dev110}/verifiers/v1/runtimes/prime.py

@@ -1,10 +1,4 @@
-"""Remote Prime sandbox runtime.
-
-`expose` (sandbox port -> public URL) uses the SDK's native exposure (`client.expose`), so a
-host-side harness/framework can reach a tool server hosted in the sandbox. The reverse
-direction (a program in the sandbox reaching a host service) is the shared host-side
-`Tunnel` (interception.tunnel), not the runtime's concern.
-"""
+"""Remote Prime VM sandbox runtime."""
 
 import asyncio
 import base64
@@ -25,7 +19,6 @@ from pydantic import Field, model_validator
 from verifiers.v1.configs.runtime import NetworkPolicyConfig
 from verifiers.v1.errors import SandboxError
 from verifiers.v1.runtimes.base import (
-    SERVICE_PORT,
     BaseRuntimeInfo,
     ProgramResult,
     Runtime,
@@ -73,15 +66,11 @@ class PrimeConfig(NetworkPolicyConfig):
     type: Literal["prime"] = "prime"
     image: str = "python:3.11-slim"
     """Docker image to run. Any pullable ref works: on the first use of an image, the
-    platform auto-builds what the sandbox needs from it (a VM image for `vm` sandboxes,
-    ~10 minutes) and caches the result, so later sandboxes on the same ref start in
+    platform auto-builds the VM image that the sandbox needs from it (~10 minutes)
+    and caches the result, so later sandboxes on the same ref start in
     seconds."""
     workdir: str | None = None
     """Working directory override; None uses the task's workdir, or /app."""
-    vm: bool = True
-    """Run as a micro-VM rather than a container (kernel features / stronger isolation)."""
-    guaranteed: bool = False
-    """Request guaranteed (vs best-effort) capacity."""
     region: str | None = None
     """Region to provision in (None = provider-chosen)."""
     labels: list[str] = Field(default_factory=list)
@@ -106,10 +95,6 @@ class PrimeConfig(NetworkPolicyConfig):
     def _validate_egress(self) -> "PrimeConfig":
         if not self.network_restricted:
             return self
-        if not self.vm:
-            raise ValueError(
-                "Prime allow/block egress lists require a VM sandbox (vm=true)"
-            )
         if not self.allow:
             return self
         validate_egress_lists(
@@ -156,11 +141,7 @@ class PrimeRuntime(Runtime):
 
     @property
     def supports_live_processes(self) -> bool:
-        return self.config.vm
-
-    @property
-    def published_port(self) -> int | None:
-        return SERVICE_PORT
+        return True
 
     async def start(self) -> None:
         from prime_sandboxes import AsyncSandboxClient, CreateSandboxRequest
@@ -186,14 +167,7 @@ class PrimeRuntime(Runtime):
             "memory_gb": self.config.memory,
             "disk_size_gb": self.config.disk,
             "gpu_count": gpu_count,
-            # -1 is prime's convention for no lifetime limit; containers with an
-            # idle timeout must carry a finite lifetime as a safety fallback (which
-            # must exceed the idle timeout)
-            "timeout_minutes": (
-                -1
-                if self.config.vm or idle_minutes is None
-                else max(EFFECTIVELY_UNBOUNDED_SECONDS // 60, idle_minutes + 1)
-            ),
+            "timeout_minutes": -1,
             "idle_timeout_minutes": idle_minutes,
             "gpu_type": gpu_type,
             "region": self.config.region,
@@ -216,8 +190,6 @@ class PrimeRuntime(Runtime):
                                 dict.fromkeys([*BASE_LABELS, *self.config.labels])
                             ),
                             docker_image=self.config.image,
-                            vm=self.config.vm,
-                            guaranteed=self.config.guaranteed,
                             environment_vars=self.env,
                             **{k: v for k, v in options.items() if v is not None},
                         )
@@ -323,11 +295,6 @@ class PrimeRuntime(Runtime):
     async def open_process(
         self, argv: list[str], env: dict[str, str]
     ) -> RuntimeProcess:
-        if not self.config.vm:
-            raise SandboxError(
-                "persistent harness sessions on Prime require a VM sandbox; "
-                "set runtime.prime.vm=true"
-            )
         try:
             process = await self._client.open_process(
                 self.info.id,
@@ -339,22 +306,11 @@ class PrimeRuntime(Runtime):
             raise SandboxError(f"prime live process failed to start: {e}") from e
         return PrimeProcess(process)
 
-    async def expose(self, port: int) -> str | None:
-        # Publish a server hosted IN the sandbox via the SDK's native port exposure → a public
-        # HTTPS URL. Removed when the sandbox is deleted in stop(), so a tool in its own prime
-        # sandbox needs no host tunnel. Port exposure is region-gated: many regions (incl. the
-        # backend default, which lands in us-central) 400 it; `us` supports it. TODO: re-enable the
-        # prime cases in the e2e `skip_if_unexposable` guard once prime exposes ports in any region.
-        try:
-            exposed = await self._client.expose(self.info.id, port)
-        except Exception as e:  # surface prime's exposure constraints actionably
-            raise SandboxError(
-                "prime port exposure failed — port exposure isn't supported in this sandbox's "
-                "region; pin `tools.runtime.region` to a region that supports it (e.g. `us`), or "
-                f"use a colocated / docker / modal tools.runtime instead. ({e})"
-            ) from e
-        logger.info("prime: exposed sandbox port %d at %s", port, exposed.url)
-        return exposed.url.rstrip("/")
+    async def expose(self, port: int) -> str:
+        raise SandboxError(
+            "Prime VM sandboxes do not support port exposure; colocate the service "
+            "with its consumer, or use a docker or modal service runtime"
+        )
 
     async def run_background(
         self, argv: list[str], env: dict[str, str], log: str
@@ -371,7 +327,7 @@ class PrimeRuntime(Runtime):
             raise SandboxError(f"prime background launch failed: {e}") from e
 
     async def _read(self, path: str, max_bytes: int | None = None) -> bytes:
-        if max_bytes is not None and self.config.vm:
+        if max_bytes is not None:
             try:
                 # VM execute_command uses bash and returns the complete output stream.
                 result = await self._client.execute_command(
@@ -386,8 +342,6 @@ class PrimeRuntime(Runtime):
             if result.exit_code:
                 raise SandboxError(f"read {path!r}: {result.stderr.strip()[-500:]}")
             return base64.b64decode(result.stdout)
-        if max_bytes is not None:
-            return await super()._read(path, max_bytes)
         # Avoid background-job log limits and base64 overhead by downloading binary data directly.
         # The temporary file is removed on every exit, and its byte read stays off the event loop.
         target = (

{verifiers-0.3.2.dev108 → verifiers-0.3.2.dev110}/verifiers/v1/task.py

@@ -104,8 +104,7 @@ class TaskData(BaseModel):
     network_allow: list[str] = Field(default_factory=lambda: ["*"])
     """Execution-time destinations requested by this task. `*` leaves the runtime
     allowlist unchanged; a concrete list replaces a wildcard or retains entries also
-    present in an existing allowlist. Prime runtimes accept host-level entries and
-    require `vm=true`."""
+    present in an existing allowlist. Prime runtimes accept host-level entries."""
     network_block: list[str] = Field(default_factory=list)
     """Execution-time destinations denied by this task and combined with runtime
     blocks. Non-empty concrete allowlists cannot be combined with blocklists. Docker

{verifiers-0.3.2.dev108 → verifiers-0.3.2.dev110}/verifiers/v1/tasksets/harbor/env.py

@@ -37,7 +37,7 @@ class HarborEnv(IsolatedVerifierEnv, vf.Env[HarborEnvConfig]):
             await agents.agent.run(task)
             return
         # Resolve the verifier's box before the solve, so an impossible pairing
-        # (e.g. a restricted Prime verifier without vm=true) costs nothing
+        # (e.g. an invalid network policy) costs nothing
         # rather than a full agent run.
         self.verifier_config(task)
         await agents.agent.run(task.defer_scoring(), collect_artifacts=True)