verifiers 0.3.1.dev54__tar.gz → 0.3.1.dev56__tar.gz

{verifiers-0.3.1.dev54 → verifiers-0.3.1.dev56}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifiers
-Version: 0.3.1.dev54
+Version: 0.3.1.dev56
 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.3.1.dev54 → verifiers-0.3.1.dev56}/verifiers/v1/acp/__init__.py

@@ -41,7 +41,6 @@ class ACPConfig:
     mcp_urls: dict[str, str] | None = None
     system_prompt: str | None = None
     session_meta: JsonObject | None = None
-    allow_empty_tool_reply: bool = False
 
 
 class ACPHarness(Harness[ConfigT]):
@@ -215,7 +214,6 @@ class ACPHarnessSession(HarnessSession):
             "mcp_urls": self.mcp_urls,
             "system_prompt": self.config.system_prompt or "",
             "session_meta": self.config.session_meta or {},
-            "allow_empty_tool_reply": self.config.allow_empty_tool_reply,
         }
         async with self._lock:
             if self._closed:

{verifiers-0.3.1.dev54 → verifiers-0.3.1.dev56}/verifiers/v1/acp/runner.py

@@ -30,8 +30,6 @@ from acp.schema import (
     PermissionOption,
     RequestPermissionResponse,
     TextContentBlock,
-    ToolCall,
-    ToolCallUpdate,
 )
 
 MAX_PACKET_BYTES = 128 * 1024 * 1024
@@ -41,20 +39,13 @@ class VerifiersACPClient(Client):
     def __init__(self) -> None:
         self.visible_reply = ""
         self.message_id: str | None = None
-        self.tool_calls: dict[str, str] = {}
 
     def reset(self) -> None:
         self.visible_reply = ""
         self.message_id = None
-        self.tool_calls = {}
 
     async def session_update(self, session_id: str, update: Any, **kwargs: Any) -> None:
-        if isinstance(update, ToolCall):
-            self.tool_calls[update.tool_call_id] = update.status or "pending"
-        elif isinstance(update, ToolCallUpdate):
-            if update.status:
-                self.tool_calls[update.tool_call_id] = update.status
-        elif isinstance(update, AgentMessageChunk) and isinstance(
+        if isinstance(update, AgentMessageChunk) and isinstance(
             update.content, TextContentBlock
         ):
             message_id = getattr(update, "message_id", None)
@@ -137,23 +128,10 @@ async def prompt(
         raise ValueError("ACP prompt has no content")
     client.reset()
     try:
-        response = await connection.prompt(session_id=session_id, prompt=blocks)
+        await connection.prompt(session_id=session_id, prompt=blocks)
     except RequestError as error:
         detail = error.data.get("details") if isinstance(error.data, dict) else None
         raise RuntimeError(detail or str(error)) from error
-
-    tool_statuses = list(client.tool_calls.values())
-    completed_tool_turn = (
-        config.get("allow_empty_tool_reply", False)
-        and response.stop_reason == "end_turn"
-        and bool(tool_statuses)
-        and all(status in ("completed", "failed") for status in tool_statuses)
-    )
-    if not client.visible_reply.strip() and not completed_tool_turn:
-        raise RuntimeError(
-            "ACP agent produced no visible reply "
-            f"(stop_reason={response.stop_reason}, tool_statuses={tool_statuses})"
-        )
     return client.visible_reply
 
 

{verifiers-0.3.1.dev54 → verifiers-0.3.1.dev56}/verifiers/v1/harnesses/openclaw/harness.py

@@ -229,8 +229,6 @@ class OpenClawHarness(ACPHarness[OpenClawHarnessConfig]):
             prompt=prompt,
             mcp_urls={},
             system_prompt=system_prompt,
-            # OpenClaw can end after its final tool completes without a text message.
-            allow_empty_tool_reply=True,
         )
 
     async def cleanup(self, trace: Trace, runtime: Runtime) -> None:

{verifiers-0.3.1.dev54 → verifiers-0.3.1.dev56}/verifiers/v1/harnesses/pi/harness.py

@@ -200,6 +200,4 @@ class PiHarness(ACPHarness[PiHarnessConfig]):
             prompt=prompt,
             # Pi's extension owns the task-scoped MCP configuration.
             mcp_urls={},
-            # Pi can end after its final tool completes without a text message.
-            allow_empty_tool_reply=True,
         )

{verifiers-0.3.1.dev54 → verifiers-0.3.1.dev56}/verifiers/v1/runtimes/prime.py

@@ -36,8 +36,9 @@ from verifiers.v1.utils.prime import ensure_prime_auth
 
 logger = logging.getLogger(__name__)
 
-MAX_LIFETIME = 24 * 60 * 60
-"""Prime's fixed cap (seconds) on any sandbox's total lifetime."""
+CONTAINER_LIFETIME = 24 * 60 * 60
+"""Fixed lifetime (seconds) of container sandboxes; only VM sandboxes support an
+unbounded lifetime."""
 
 
 BASE_LABELS: list[str] = []
@@ -102,10 +103,15 @@ class PrimeConfig(NetworkPolicyConfig):
 
     @model_validator(mode="after")
     def _validate_idle_timeout(self) -> "PrimeConfig":
-        if self.idle_timeout is not None and self.idle_timeout > MAX_LIFETIME:
+        if (
+            not self.vm
+            and self.idle_timeout is not None
+            and self.idle_timeout > CONTAINER_LIFETIME
+        ):
             raise ValueError(
                 f"idle_timeout ({self.idle_timeout}s) must not exceed the "
-                f"{MAX_LIFETIME}s ({MAX_LIFETIME // 3600}h) max sandbox lifetime"
+                f"{CONTAINER_LIFETIME}s ({CONTAINER_LIFETIME // 3600}h) container "
+                "sandbox lifetime"
             )
         return self
 
@@ -161,7 +167,7 @@ class PrimeRuntime(Runtime):
         # GB). gpu_type/region are only sent when set (else provider-chosen).
         gpu_type, gpu_count = parse_gpu(self.config.gpu)
         # prime's idle timeout is in whole minutes; convert from the seconds config surface
-        # (floored to the SDK's 1-minute minimum).
+        # (raised to the SDK's 1-minute minimum).
         idle_minutes = (
             max(1, math.ceil(self.config.idle_timeout / 60))
             if self.config.idle_timeout is not None
@@ -172,7 +178,8 @@ class PrimeRuntime(Runtime):
             "memory_gb": self.config.memory,
             "disk_size_gb": self.config.disk,
             "gpu_count": gpu_count,
-            "timeout_minutes": MAX_LIFETIME // 60,
+            # -1 is prime's convention for no lifetime limit (VM-only)
+            "timeout_minutes": -1 if self.config.vm else CONTAINER_LIFETIME // 60,
             "idle_timeout_minutes": idle_minutes,
             "gpu_type": gpu_type,
             "region": self.config.region,
@@ -278,7 +285,9 @@ class PrimeRuntime(Runtime):
             result = await self._client.run_background_job(
                 self.info.id,
                 shlex.join(argv),
-                timeout=MAX_LIFETIME,
+                # the SDK poll needs a finite deadline: the container lifetime, or
+                # effectively unbounded for VM sandboxes
+                timeout=365 * 24 * 60 * 60 if self.config.vm else CONTAINER_LIFETIME,
                 working_dir=self.config.workdir,
                 env=self.process_env(env),
                 poll_interval=1,

{verifiers-0.3.1.dev54 → verifiers-0.3.1.dev56}/verifiers/v1/utils/compile.py

@@ -8,6 +8,7 @@ from collections.abc import Collection
 from verifiers.v1.configs.runtime import NetworkPolicyConfig
 from verifiers.v1.harness import Harness
 from verifiers.v1.runtimes import (
+    PrimeConfig,
     RuntimeConfig,
     SubprocessConfig,
     runtime_is_local,
@@ -114,14 +115,14 @@ def validate_pairing(
 def cap_remote_agent_timeout(
     agent_timeout: float | None, runtime_config: RuntimeConfig, task: Task
 ) -> float | None:
-    """Remote sandboxes live at most 24 hours: cap the agent timeout there (with a
-    warning) so a long run times out cleanly instead of the provider killing the box
-    mid-run."""
-    if (
-        agent_timeout is not None
-        and agent_timeout > 24 * 60 * 60
-        and not runtime_is_local(runtime_config)
-    ):
+    """Remote sandboxes other than Prime VMs (which have no lifetime limit) live at
+    most 24 hours: cap the agent timeout there (with a warning) so a long run times
+    out cleanly instead of the provider killing the box mid-run."""
+    if agent_timeout is None or runtime_is_local(runtime_config):
+        return agent_timeout
+    if isinstance(runtime_config, PrimeConfig) and runtime_config.vm:
+        return agent_timeout
+    if agent_timeout > 24 * 60 * 60:
         logger.warning(
             "task %r resolves to a %.1f-hour agent timeout, but %s sandboxes have a "
             "maximum lifetime of 24 hours; capping it at 24 hours",