verifiers 0.3.2.dev162__tar.gz → 0.3.2.dev164__tar.gz

{verifiers-0.3.2.dev162 → verifiers-0.3.2.dev164}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifiers
-Version: 0.3.2.dev162
+Version: 0.3.2.dev164
 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.2.dev162 → verifiers-0.3.2.dev164}/verifiers/v1/clients/base.py

@@ -7,9 +7,6 @@ from openai import AsyncOpenAI
 
 from verifiers.v1.configs.client import BaseClientConfig, resolve_api_key
 
-# No read timeout: agentic completions are slow and the rollout timeout is the real
-# backstop. The connect bound stays so an unreachable endpoint still fails fast.
-DEFAULT_TIMEOUT = httpx.Timeout(connect=5.0, read=None, write=None, pool=None)
 DEFAULT_LIMITS = httpx.Limits(max_connections=1000, max_keepalive_connections=100)
 MAX_RETRIES = 0
 """No client-side retries: failures surface to the harness SDK and the trace instead of
@@ -19,14 +16,20 @@ being silently reattempted."""
 VERSION_SEGMENT = re.compile(r"v\d+")
 
 
+def build_async_httpx(config: BaseClientConfig) -> httpx.AsyncClient:
+    return httpx.AsyncClient(
+        timeout=httpx.Timeout(**config.timeout.model_dump()), limits=DEFAULT_LIMITS
+    )
+
+
 def build_async_openai(config: BaseClientConfig) -> AsyncOpenAI:
+    # The SDK adopts the http client's timeout, so it is configured in one place.
     return AsyncOpenAI(
         base_url=config.base_url,
         api_key=resolve_api_key(config),
         default_headers=config.headers or None,
-        timeout=DEFAULT_TIMEOUT,
         max_retries=MAX_RETRIES,
-        http_client=httpx.AsyncClient(timeout=DEFAULT_TIMEOUT, limits=DEFAULT_LIMITS),
+        http_client=build_async_httpx(config),
     )
 
 

{verifiers-0.3.2.dev162 → verifiers-0.3.2.dev164}/verifiers/v1/clients/eval.py

@@ -7,7 +7,7 @@ import httpx
 from pydantic import ValidationError
 from pydantic_core import from_json, to_json
 
-from verifiers.v1.clients.base import DEFAULT_LIMITS, DEFAULT_TIMEOUT, join_url
+from verifiers.v1.clients.base import build_async_httpx, join_url
 from verifiers.v1.clients.client import SESSION_ID_HEADER, Client, RelayReply
 from verifiers.v1.configs.client import BaseClientConfig, resolve_api_key
 from verifiers.v1.dialects import Dialect
@@ -68,7 +68,7 @@ class EvalClient(Client):
         # Keep endpoint headers separate so they can override intercepted request headers before
         # the dialect's provider authentication is applied.
         self.headers = dict(config.headers or {})
-        self.client = httpx.AsyncClient(timeout=DEFAULT_TIMEOUT, limits=DEFAULT_LIMITS)
+        self.client = build_async_httpx(config)
 
     async def get_response(
         self,

{verifiers-0.3.2.dev162 → verifiers-0.3.2.dev164}/verifiers/v1/configs/client.py

@@ -26,6 +26,21 @@ PRIME_INFERENCE_HOST = "pinference.ai"
 PRIME_TEAM_ID_HEADER = "X-Prime-Team-ID"
 
 
+class ClientTimeoutConfig(BaseConfig):
+    """Timeouts (in seconds) for each phase of an HTTP request to the endpoint; `None`
+    waits indefinitely. Distinct from the agent's stage timeouts, which bound a rollout."""
+
+    connect: float | None = Field(30.0, gt=0)
+    """Time to establish a connection, so an unreachable endpoint still fails fast."""
+    read: float | None = Field(None, gt=0)
+    """Time between received bytes. Unbounded by default: agentic completions are slow
+    and the rollout timeout is the real backstop."""
+    write: float | None = Field(None, gt=0)
+    """Time between sent bytes."""
+    pool: float | None = Field(None, gt=0)
+    """Time to acquire a connection from the pool."""
+
+
 class BaseClientConfig(BaseConfig):
     """An OpenAI-compatible endpoint. The API key is read from an env var."""
 
@@ -33,6 +48,7 @@ class BaseClientConfig(BaseConfig):
     api_key_var: str = "PRIME_API_KEY"
     headers: dict[str, str] = Field(default_factory=dict)
     """Extra HTTP headers sent on every request."""
+    timeout: ClientTimeoutConfig = ClientTimeoutConfig()
 
     @model_validator(mode="after")
     def apply_prime_config(self) -> "BaseClientConfig":
@@ -65,7 +81,7 @@ class EvalClientConfig(BaseClientConfig):
 
 class TrainClientConfig(BaseClientConfig):
     """Training: a vLLM `/inference/v1/generate` endpoint with client-side tokenization (via
-    `TrainClient`), so responses carry token ids + logprobs. Needs a running vLLM engine."""
+    `TrainClient`), so responses carry token IDs and logprobs. Needs a running vLLM engine."""
 
     type: Literal["train"] = "train"
     renderer: RendererConfig | None = None

{verifiers-0.3.2.dev162 → verifiers-0.3.2.dev164}/verifiers/v1/tasksets/harbor/taskset.py

@@ -372,7 +372,8 @@ class HarborTask(Task[HarborData, State, HarborTaskConfig]):
     ) -> float | dict[str, float]:
         # By absolute path, in the runtime's configured workdir: Harbor execs the
         # script the same way, and scripts do grade the agent's work at `$PWD`.
-        await runtime.run(
+        # The reward file is authoritative even when the script exits nonzero.
+        result = await runtime.run(
             ["bash", "/tests/test.sh"], resolve_env(self.data.verifier_env)
         )
         scores = await self.read_reward_json(runtime)
@@ -393,9 +394,13 @@ class HarborTask(Task[HarborData, State, HarborTaskConfig]):
                 .decode()
                 .strip()
             )
-            return float(reward or 0)
-        except (SandboxError, OSError, ValueError):
-            return 0.0
+            return REWARD_JSON_ADAPTER.validate_python(float(reward))
+        except (SandboxError, OSError, ValueError) as exc:
+            raise TaskError(
+                "Harbor verifier produced no valid reward.json or reward.txt "
+                f"(exit {result.exit_code}): "
+                f"{(result.stderr or result.stdout).strip()[-500:]}"
+            ) from exc
 
     async def read_reward_json(
         self, runtime: Runtime