verifiers 0.2.2.dev53__py3-none-any.whl → 0.2.2.dev55__py3-none-any.whl

verifiers/v1/__init__.py

@@ -115,10 +115,10 @@ from verifiers.v1.taskset import Taskset
 from verifiers.v1.trace import (
     TRACE_VERSION,
     AgentInfo,
+    AgentSpan,
     Branch,
     Error,
     EvalRunInfo,
-    GenerationSpan,
     ModelCall,
     Reward,
     RunInfo,
@@ -144,7 +144,6 @@ from verifiers.v1.types import (
     Response,
     Sampling,
     SamplingConfig,
-    StrictBaseModel,
     SystemMessage,
     TextContentPart,
     Tool,
@@ -177,7 +176,6 @@ __all__ = [  # noqa: RUF022 - grouped by public API area
     "Response",
     "Sampling",
     "SamplingConfig",
-    "StrictBaseModel",
     "SystemMessage",
     "TextContentPart",
     "Tool",
@@ -213,7 +211,7 @@ __all__ = [  # noqa: RUF022 - grouped by public API area
     "Timing",
     "TimeSpan",
     "TimeSplit",
-    "GenerationSpan",
+    "AgentSpan",
     "Error",
     # decorators
     "stop",

verifiers/v1/artifacts.py

@@ -8,9 +8,7 @@ import uuid
 from pathlib import PurePosixPath
 from typing import TYPE_CHECKING
 
-from pydantic import Field
-
-from verifiers.v1.types import StrictBaseModel
+from pydantic import BaseModel, Field
 
 if TYPE_CHECKING:
     from verifiers.v1.runtimes import Runtime
@@ -25,7 +23,7 @@ MAX_ARTIFACT_BYTES = 32 * 1024 * 1024
 agent's image, so the repo is already there and only its output has to travel."""
 
 
-class Artifact(StrictBaseModel):
+class Artifact(BaseModel):
     """One path to restore at the same location in another runtime."""
 
     source: str

verifiers/v1/cli/dashboard/eval.py

@@ -393,18 +393,19 @@ def _breakdown(scored: list[Trace], done: list[Trace]) -> Table | None:
     phase_count: dict[str, int] = {}
     model_secs = harness_secs = 0.0
     for trace in done:
-        prompt, completion, cached, reasoning, _ = _tokens(trace)
-        total_in += prompt
-        total_out += completion
-        if cached is not None:
-            total_cached += cached
-            have_cached = True
-        if reasoning is not None:
-            total_reasoning += reasoning
-            have_reasoning = True
-        if trace.usage is not None and trace.usage.cost is not None:
-            total_cost += trace.usage.cost
-            have_cost = True
+        total_in += trace.num_input_tokens
+        total_out += trace.num_output_tokens
+        usage = trace.usage
+        if usage is not None:
+            if usage.cached_input_tokens is not None:
+                total_cached += usage.cached_input_tokens
+                have_cached = True
+            if usage.reasoning_tokens is not None:
+                total_reasoning += usage.reasoning_tokens
+                have_reasoning = True
+            if usage.cost is not None:
+                total_cost += usage.cost
+                have_cost = True
         # Judge / auxiliary scoring calls (off the message graph) shown separately from the agent's.
         judge = Usage.aggregate(trace.extra_usage)
         if judge is not None:
@@ -413,13 +414,13 @@ def _breakdown(scored: list[Trace], done: list[Trace]) -> Table | None:
             if judge.cost is not None:
                 total_judge_cost += judge.cost
             have_judge = True
-        for phase in ("boot", "setup", "generation", "finalize", "scoring"):
+        for phase in ("boot", "setup", "agent", "finalize", "scoring"):
             span = getattr(trace.timing, phase)
             if span.end:  # phase was timed for this rollout
                 phase_secs[phase] = phase_secs.get(phase, 0.0) + span.duration
                 phase_count[phase] = phase_count.get(phase, 0) + 1
-        model_secs += trace.timing.generation.model.duration
-        harness_secs += trace.timing.generation.harness.duration
+        model_secs += trace.timing.agent.model.duration
+        harness_secs += trace.timing.agent.harness.duration
     if (
         total_in
         or total_out
@@ -448,12 +449,12 @@ def _breakdown(scored: list[Trace], done: list[Trace]) -> Table | None:
             usage.append(cost)
         grid.add_row("usage", "  ·  ".join(usage))
     time_segments = []
-    for phase in ("boot", "setup", "generation", "finalize", "scoring"):
+    for phase in ("boot", "setup", "agent", "finalize", "scoring"):
         count = phase_count.get(phase)
         if not count:
             continue
         segment = f"{phase} {format_time(phase_secs[phase] / count)}"
-        if phase == "generation":
+        if phase == "agent":
             segment += (
                 f" (model {format_time(model_secs / count)}"
                 f" + harness {format_time(harness_secs / count)})"
@@ -464,26 +465,6 @@ def _breakdown(scored: list[Trace], done: list[Trace]) -> Table | None:
     return grid if grid.row_count else None
 
 
-def _tokens(trace: Trace) -> tuple[int, int, int | None, int | None, int]:
-    """Input/output tokens summed across all branches: per branch, output is every assistant
-    (completion) token generated across its turns and input is the fed-in tokens counted once
-    (system + user + tool) — the final sequence minus everything the model generated. A rollout
-    yields one training sample per branch (a linear trace is a single branch; compaction and
-    subagents add more), so the totals sum them — matching `Trace.num_input_tokens` /
-    `Trace.num_output_tokens`, whose sum is `num_total_tokens`.
-
-    Both counts come from provider-reported usage. Returns the branch count from the same derived
-    view so each dashboard tick materializes it once."""
-    usage = trace.usage
-    cached = usage.cached_input_tokens if usage else None
-    reasoning = usage.reasoning_tokens if usage else None
-    branches = trace.branches
-    nbranches = len(branches)
-    prompt = sum(b.num_input_tokens for b in branches)
-    completion = sum(b.num_output_tokens for b in branches)
-    return prompt, completion, cached, reasoning, nbranches
-
-
 def _stage(trace: Trace) -> str:
     """The stage a live (not-yet-done) rollout is in, derived from its trace's timing
     spans — the engine opens and closes each span exactly at the stage transitions, so
@@ -495,7 +476,7 @@ def _stage(trace: Trace) -> str:
     for stage, span in (
         ("scoring", trace.timing.scoring),
         ("finalize", trace.timing.finalize),
-        ("running", trace.timing.generation),
+        ("running", trace.timing.agent),
         ("setup", trace.timing.setup),
         ("boot", trace.timing.boot),
     ):
@@ -551,7 +532,9 @@ def Rows(groups: list[list[RunSlot]], now: float, runtime_type: str) -> Table:
             base = f"name={task.name[:32]}" if task.name else f"idx={task.idx}"
             if not slot.traces:
                 if slot.done:  # the env's rollout() itself failed before any trace
-                    error = slot.episode.error if slot.episode is not None else None
+                    error = (
+                        slot.episode.last_error if slot.episode is not None else None
+                    )
                     group_rows.append(
                         (
                             "error",
@@ -602,7 +585,7 @@ def Rows(groups: list[list[RunSlot]], now: float, runtime_type: str) -> Table:
                 end = (
                     t.timing.scoring.end
                     or t.timing.finalize.end
-                    or t.timing.generation.end
+                    or t.timing.agent.end
                     # a rollout that errored in boot/setup has only that span's end — freeze there
                     # once done, else (still running) the timer would grow off `now` forever
                     or (
@@ -612,8 +595,12 @@ def Rows(groups: list[list[RunSlot]], now: float, runtime_type: str) -> Table:
                     )
                     or now
                 )
-                prompt, completion, cached, reasoning, nbranches = _tokens(t)
-                cost = t.usage.cost if t.usage else None
+                prompt, completion = t.num_input_tokens, t.num_output_tokens
+                nbranches = t.num_branches
+                usage = t.usage
+                cached = usage.cached_input_tokens if usage else None
+                reasoning = usage.reasoning_tokens if usage else None
+                cost = usage.cost if usage else None
                 tokens = ""
                 if prompt or completion:
                     tokens = f"{format_count(prompt)}/{format_count(completion)} tokens"

verifiers/v1/cli/debug.py

@@ -123,16 +123,16 @@ def record_debug_error(
     action_timeout: float | None,
 ) -> None:
     now = time.time()
-    for span in (trace.timing.boot, trace.timing.setup, trace.timing.generation):
+    for span in (trace.timing.boot, trace.timing.setup, trace.timing.agent):
         if span.start and not span.end:
             span.end = now
-    in_action = bool(trace.timing.generation.start)
+    in_action = bool(trace.timing.agent.start)
     stage = (
         "debug action" if in_action else "setup" if trace.timing.setup.start else "boot"
     )
     timeout = action_timeout if in_action else setup_timeout
     error_start = (
-        trace.timing.generation.start
+        trace.timing.agent.start
         if in_action
         else trace.timing.setup.start or trace.timing.boot.start
     )
@@ -234,9 +234,9 @@ async def debug_task(task: Task, config: DebugConfig) -> tuple[Trace, bool]:
         await runtime.prepare_execution([])
         trace.timing.setup.end = time.time()
 
-        trace.timing.generation.start = time.time()
+        trace.timing.agent.start = time.time()
         debug.update(await run_action(runtime, config))
-        trace.timing.generation.end = time.time()
+        trace.timing.agent.end = time.time()
         if not debug.get("ok"):
             record_action_failure(trace, debug)
         trace.stop(str(debug["reason"]))
@@ -246,7 +246,7 @@ async def debug_task(task: Task, config: DebugConfig) -> tuple[Trace, bool]:
     except Exception as e:  # noqa: BLE001 - persist any framework failure on the trace
         record_debug_error(trace, debug, e, setup_timeout, config.timeout.total)
     finally:
-        trace.split_generation()
+        trace.split_agent_time()
         trace.info["debug"] = debug
         try:
             await runtime.stop()

verifiers/v1/cli/replay.py

@@ -31,7 +31,7 @@ from verifiers.v1.cli.resolve import narrow_taskset_config
 from verifiers.v1.configs.agent import WireAgentConfig
 from verifiers.v1.configs.cli.replay import ReplayConfig
 from verifiers.v1.state import state_cls
-from verifiers.v1.task import Task, WireTaskData, task_data_cls
+from verifiers.v1.task import Task, WireTaskData
 from verifiers.v1.trace import Trace
 from verifiers.v1.utils.interrupt import install_interrupt
 from verifiers.v1.utils.logging import setup_logging
@@ -76,7 +76,7 @@ async def run_replay(config: ReplayConfig, source: Path, out: Path) -> list[Trac
             "score() — multi-agent runs don't support replay"
         )
     task_cls = vf.task_type(config.taskset.id)
-    data_cls = task_data_cls(task_cls)
+    data_cls = task_cls.data_type()
     # `WireTaskData` reads any taskset's saved task without importing its Task type.
     # An episode may hold no traces (its env hooks failed before any agent ran);
     # there's nothing to re-score, so it drops out in the flatten. Each kept trace
@@ -84,7 +84,7 @@ async def run_replay(config: ReplayConfig, source: Path, out: Path) -> list[Trac
     episodes = read_episodes(
         source, Trace[WireTaskData, state_cls(task_cls), WireAgentConfig]
     )
-    sourced = [(trace, e.env) for e in episodes for trace in e.traces]
+    sourced = [(trace, e.env.id) for e in episodes for trace in e.traces]
     if config.num_traces is not None:
         sourced = sourced[: config.num_traces]
     traces = [trace for trace, _ in sourced]

verifiers/v1/env.py

@@ -20,7 +20,7 @@ from verifiers.v1.configs.env import (
     _declared_agent_configs,
     default_agent_harness,
 )
-from verifiers.v1.episode import Episode
+from verifiers.v1.episode import EnvInfo, Episode
 from verifiers.v1.errors import EnvError, boundary
 from verifiers.v1.harness import Harness, HarnessConfig
 from verifiers.v1.interception import (
@@ -257,7 +257,7 @@ class Env(ABC, Generic[ConfigT]):
         completed subset, its exception on the episode's `errors`. `on_trace` observes
         each agent-run's trace at mint; `on_discard` its abandonment (a per-agent
         retry mints a replacement)."""
-        episode = Episode(env=self.config.env_id)
+        episode = Episode(env=EnvInfo(id=self.config.env_id))
         agents = self._episode_agents(ctx, episode.traces, on_trace, on_discard)
         try:
             async with asyncio.timeout(self.config.timeout.episode):

verifiers/v1/envs/agentic_judge/env.py

@@ -19,10 +19,9 @@ import re
 import tomllib
 from pathlib import Path
 
-from pydantic import Field, field_validator
+from pydantic import BaseModel, Field, field_validator
 
 import verifiers.v1 as vf
-from verifiers.v1.types import StrictBaseModel
 from verifiers.v1.utils.compile import validate_pairing
 
 VERDICT_FILE = "/tmp/verdict.json"
@@ -39,7 +38,7 @@ TASK_SECTION = """\
 {prompt}"""
 
 
-class Criterion(StrictBaseModel):
+class Criterion(BaseModel):
     """One rubric criterion — the plugged rubric judge's format, mirrored so the
     same `criteria` files grade both judges."""
 

verifiers/v1/episode.py

@@ -3,51 +3,79 @@
 import uuid
 from typing import Generic
 
-from pydantic import Field
+from pydantic import BaseModel, Field
 
 from verifiers.v1.configs.agent import WireAgentConfig
 from verifiers.v1.state import State, StateT
 from verifiers.v1.task import DataT, WireTaskData
 from verifiers.v1.trace import AgentConfigT, Error, Trace
-from verifiers.v1.types import StrictBaseModel
+from verifiers.v1.types import Usage
 
 
-class Episode(StrictBaseModel, Generic[DataT, StateT, AgentConfigT]):
-    """One run of a task, whole: its identity and standing (`id`, `env`, `errors`)
-    next to its flat `traces` — the object `finalize()` receives, the engine
-    returns, and the durability envelope: one episode is one `traces.jsonl` line
-    and one serve reply, so it persists and arrives whole or not at all — a torn
-    line is the whole episode owed again, and a failure before any trace minted
-    still leaves its errors here. Episode standing lives ONLY here (zero
-    redundancy on the traces); per-trace facts (`agent`, per-trace errors) stay
-    on the traces, which remain the atomic unit.
+class EnvInfo(BaseModel):
+    """The env that ran the episode, self-describing without the run's config."""
 
-    `errors` are failures not attributable to any one trace (the env's
-    `run`/`finalize` hooks, plus prior attempts' when retried).
+    id: str = ""
+    """`EnvConfig.env_id`, e.g. `agentic-judge+gsm8k-v1`."""
 
-    The type parameters serve the wire loaders: `WireEpisode` reads any taskset's
-    episodes without importing the taskset."""
+
+class Episode(BaseModel, Generic[DataT, StateT, AgentConfigT]):
+    """The artifact Env.run produces. Contains multiple agents' traces."""
 
     id: str = Field(default_factory=lambda: uuid.uuid4().hex)
-    env: str = ""
-    """The env that ran the episode (`EnvConfig.env_id`, e.g.
-    `agentic-judge+gsm8k-v1`)."""
+
+    env: EnvInfo = Field(default_factory=EnvInfo)
+    """The env that produced this episode."""
     ok: bool = False
-    """THE success sentinel — the resume unit's keep-verdict, stamped by the
-    engine when the final attempt's hooks and every trace concluded clean.
-    Distinct from `errors` emptiness: a retried-and-recovered episode is `ok`
-    and still keeps its earlier attempts' errors."""
+    """Whether the episode completed successfully."""
     errors: list[Error] = Field(default_factory=list)
+    """Every error captured across attempts, oldest to newest."""
     traces: list[Trace[DataT, StateT, AgentConfigT]] = Field(default_factory=list)
+    """Every agent's trace, in completion order."""
 
     @property
-    def error(self) -> Error | None:
+    def last_error(self) -> Error | None:
+        """The last episode-level error captured across attempts."""
         return self.errors[-1] if self.errors else None
 
+    @property
+    def usage(self) -> Usage | None:
+        """Provider-reported usage summed across every trace's model calls;
+        judge/off-graph usage stays on the traces (`Trace.extra_usage`)."""
+        return Usage.aggregate(u for t in self.traces if (u := t.usage) is not None)
+
+    @property
+    def num_input_tokens(self) -> int:
+        """Fed-in tokens (system + user + tool), summed across traces."""
+        return sum(t.num_input_tokens for t in self.traces)
+
+    @property
+    def num_output_tokens(self) -> int:
+        """Model-generated tokens across all turns, summed across traces."""
+        return sum(t.num_output_tokens for t in self.traces)
+
+    @property
+    def num_total_tokens(self) -> int:
+        """Final sequence lengths per branch, summed across traces."""
+        return sum(t.num_total_tokens for t in self.traces)
+
+    @property
+    def num_turns(self) -> int:
+        """Sampled turns, summed across traces."""
+        return sum(t.num_turns for t in self.traces)
+
+    @property
+    def by_agent(self) -> dict[str, list[Trace[DataT, StateT, AgentConfigT]]]:
+        """Traces grouped by agent name (e.g. n solvers), in completion order."""
+        grouped: dict[str, list[Trace[DataT, StateT, AgentConfigT]]] = {}
+        for trace in self.traces:
+            grouped.setdefault(trace.agent.name, []).append(trace)
+        return grouped
+
     @classmethod
     def of(cls, trace: Trace, env: str = "") -> "Episode":
         """The single-agent record: one trace as its own episode."""
-        return cls(env=env, traces=[trace], ok=trace.ok)
+        return cls(env=EnvInfo(id=env), traces=[trace], ok=trace.ok)
 
 
 WireEpisode = Episode[WireTaskData, State, WireAgentConfig]

verifiers/v1/graph.py

@@ -25,7 +25,7 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
 import numpy as np
-from pydantic import ConfigDict, Field, field_serializer, field_validator
+from pydantic import BaseModel, ConfigDict, Field, field_serializer, field_validator
 from pydantic.json_schema import SkipJsonSchema
 from renderers.base import MultiModalData, PlaceholderRange, RenderedTokens
 
@@ -34,7 +34,6 @@ from verifiers.v1.types import (
     KeptTokens,
     Message,
     Response,
-    StrictBaseModel,
     TextContentPart,
     Tool,
     ToolMessage,
@@ -62,7 +61,7 @@ def _decode_ndarray(d: dict) -> np.ndarray:
     return np.frombuffer(d["data"], dtype=np.dtype(d["dtype"])).reshape(d["shape"])
 
 
-class MessageNode(StrictBaseModel):
+class MessageNode(BaseModel):
     """One message in the graph: a message plus the tokens it adds to the cumulative
     sequence. Concatenating a root→leaf path's nodes reconstructs that branch's full token
     sequence; the mask/logprobs make it a training sample."""
@@ -121,7 +120,7 @@ class MessageNode(StrictBaseModel):
     sampling-replay training. Rides the wire as raw-bytes `__nd__` dicts; kept off disk
     by the dump-site `exclude` in prime-rl."""
 
-    model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True)
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
     @field_serializer("multi_modal_data")
     def serialize_multi_modal_data(self, mmd: MultiModalData | None) -> dict | None:

verifiers/v1/judge.py

@@ -62,7 +62,7 @@ from verifiers.v1.configs.judge import (
 )
 from verifiers.v1.dialects.chat import message_to_wire
 from verifiers.v1.scoring import parse_judge_choice
-from verifiers.v1.types import Messages, StrictBaseModel, Usage
+from verifiers.v1.types import Messages, Usage
 from verifiers.v1.utils.generic import concrete_type
 
 if TYPE_CHECKING:
@@ -72,7 +72,7 @@ if TYPE_CHECKING:
 ParsedT = TypeVar("ParsedT")
 
 
-class JudgeResponse(StrictBaseModel, Generic[ParsedT]):
+class JudgeResponse(BaseModel, Generic[ParsedT]):
     text: str
     parsed: ParsedT | None = None
     usage: Usage | None = None
@@ -197,8 +197,7 @@ class Judge(Generic[ParsedT, ConfigT]):
                         )
                     if response.parsed is None:
                         raise RuntimeError(
-                            f"judge returned no parseable structured output "
-                            f"(finish_reason={choice.finish_reason})"
+                            f"judge returned no parseable structured output (finish_reason={choice.finish_reason})"
                         )
                 else:
                     completion = await client.chat.completions.create(**kwargs)

verifiers/v1/judges/rubric.py

@@ -9,13 +9,13 @@ from functools import cached_property
 from pathlib import Path
 from typing import cast
 
-from pydantic import Field, field_validator
+from pydantic import BaseModel, Field, field_validator
 
 from verifiers.v1.configs.judge import JudgeConfig
 from verifiers.v1.judge import Judge, JudgeView, judge_question, judge_response
 from verifiers.v1.task import TaskData
 from verifiers.v1.trace import Trace
-from verifiers.v1.types import ID, StrictBaseModel
+from verifiers.v1.types import ID
 
 RUBRIC_PROMPT = (Path(__file__).resolve().parent / "rubric.txt").read_text(
     encoding="utf-8"
@@ -56,7 +56,7 @@ def first_verdicts_object(text: str) -> dict | None:
     return None
 
 
-class Criterion(StrictBaseModel):
+class Criterion(BaseModel):
     name: str
     """Key for the criterion's metric (`<judge name>/<name>`) and its `weights` override."""
     text: str
@@ -109,13 +109,13 @@ class RubricJudgeConfig(JudgeConfig):
     handle either. Transient HTTP failures are already retried by the OpenAI client."""
 
 
-class CriterionVerdict(StrictBaseModel):
+class CriterionVerdict(BaseModel):
     name: str
     reason: str
     verdict: str
 
 
-class RubricVerdicts(StrictBaseModel):
+class RubricVerdicts(BaseModel):
     verdicts: list[CriterionVerdict]
 
 

verifiers/v1/legacy.py

@@ -36,8 +36,8 @@ from verifiers.v1.serve.types import (
 from verifiers.v1.task import WireTaskData
 from verifiers.v1.trace import (
     AgentInfo,
+    AgentSpan,
     Error,
-    GenerationSpan,
     ModelCall,
     Reward,
     TimeSpan,
@@ -199,7 +199,8 @@ def _to_v1_tokens(raw: Any) -> TurnTokens | None:
 def _timing(raw: Any) -> Timing:
     """Map the v0 timing record's generation/scoring durations onto a v1 ``Timing``
     (we only have durations, so each span is encoded as start=0, end=duration).
-    v0's per-turn ``model``/``env`` span collections carry the generation split."""
+    v0's ``generation`` duration becomes the agent span; its per-turn ``model``/``env``
+    span collections carry the model/harness split."""
 
     def _dur(node: Any) -> float:
         if isinstance(node, dict):
@@ -212,7 +213,7 @@ def _timing(raw: Any) -> Timing:
 
     raw = raw or {}
     return Timing(
-        generation=GenerationSpan(
+        agent=AgentSpan(
             start=0.0,
             end=_dur(raw.get("generation")),
             model=TimeSplit(duration=_dur(raw.get("model"))),

verifiers/v1/rollout.py

@@ -297,7 +297,7 @@ class RolloutRun:
             raise
         now = time.time()
         self.trace.timing.setup.end = now
-        self.trace.timing.generation.start = now
+        self.trace.timing.agent.start = now
         return True
 
     async def step(self, messages: Messages | None = None) -> bool:
@@ -397,8 +397,8 @@ class RolloutRun:
             try:
                 await self._stack.aclose()
             finally:
-                if trace.timing.generation.start and not trace.timing.generation.end:
-                    trace.timing.generation.end = time.time()
+                if trace.timing.agent.start and not trace.timing.agent.end:
+                    trace.timing.agent.end = time.time()
             if not self._failed and self._opened:
                 trace.timing.finalize.start = time.time()
                 async with boundary(TaskError, "task finalize"):
@@ -430,13 +430,13 @@ class RolloutRun:
             for span in (
                 trace.timing.boot,
                 trace.timing.setup,
-                trace.timing.generation,
+                trace.timing.agent,
                 trace.timing.finalize,
                 trace.timing.scoring,
             ):
                 if span.start and not span.end:
                     span.end = now
-            trace.split_generation()
+            trace.split_agent_time()
             if runtime is not None:
                 try:
                     await self.harness.cleanup(trace, runtime)

verifiers/v1/serve/server.py

@@ -22,7 +22,7 @@ from verifiers.v1.serve.types import (
     RunRequest,
     RunResponse,
 )
-from verifiers.v1.task import Task, task_data_cls
+from verifiers.v1.task import Task
 from verifiers.v1.types import SamplingConfig
 
 logger = logging.getLogger(__name__)
@@ -39,7 +39,7 @@ class EnvServer:
         self.taskset_id = config.taskset.id
         self.env = load_environment(config)
         self.task_cls = type(self.env.taskset).task_type()
-        self.data_cls = task_data_cls(self.task_cls)
+        self.data_cls = self.task_cls.data_type()
         # A dispatched task is its client-side model_dump(): a field excluded from
         # serialization would vanish on the wire and rebuild silently defaulted, so
         # refuse to serve such a taskset.

verifiers/v1/state.py

@@ -4,14 +4,13 @@ Tool servers synchronize it through the interception state channel. It is exclud
 from serialized traces.
 """
 
-from pydantic import ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field
 from typing_extensions import TypeVar
 
-from verifiers.v1.types import StrictBaseModel
 from verifiers.v1.utils.generic import concrete_type
 
 
-class State(StrictBaseModel):
+class State(BaseModel):
     model_config = ConfigDict(ser_json_inf_nan="constants")
     artifacts: dict[str, bytes] = Field(default_factory=dict)
 

verifiers/v1/task.py

@@ -1,25 +1,10 @@
-"""Task data, configuration, behavior, and scoring.
-
-`TaskData` is the wire half: a frozen pydantic model carrying everything a rollout's
-row IS — the base fields plus your typed, task-specific fields. It rides on
-`trace.task.data`, is what `traces.jsonl` stores, and what tool servers receive
-over the `/task` channel. Subclass it per dataset.
-
-`Task` is the behavior half: runtime prep (`setup`/`finalize`), server declarations
-(`tools`), well-formedness (`validate`), and per-trace judgement
-(`@reward`/`@metric` methods plus the plugged judges from `config.judges`, run by
-`score`). Subclass per dataset and parameterize `Task[MyData, MyState, MyConfig]`
-(all three default); judgement that compares sibling traces lives on
-`Env.finalize` instead.
-
-A Task instance is shared across its rollouts (`-r n` runs hold the same instance),
-so hooks must not stash per-rollout state on `self` — that lives on the trace
-(`trace.state`).
-
-On the wire only the data travels (plus the producing class's name,
-`trace.task.type`): a saved row reads back as `WireTaskData` without importing the
-taskset; a re-scoring consumer (`replay`) rebuilds the declared `TaskData` type and
-wraps it in the declared `Task` — one task type per taskset.
+"""Task data + behavior.
+
+`TaskData` is the wire half: a frozen pydantic model carrying the data which
+initializes a task instance. Rides on `trace.task.data` in `traces.jsonl`.
+
+`Task` is the behavior half: runtime prep (`setup`/`finalize`), tool declarations
+(`tools`), and scoring (`@reward`/`@metric`) methods.
 """
 
 from __future__ import annotations
@@ -30,7 +15,7 @@ import logging
 from collections.abc import Mapping
 from typing import TYPE_CHECKING, ClassVar, Generic, Self
 
-from pydantic import ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field
 from pydantic_config import BaseConfig
 from typing_extensions import TypeVar
 
@@ -39,7 +24,7 @@ from verifiers.v1.configs.task import TaskConfig
 from verifiers.v1.decorators import discover_decorated, invoke_all
 from verifiers.v1.errors import TaskError, boundary
 from verifiers.v1.state import StateT
-from verifiers.v1.types import Messages, StrictBaseModel, content_text
+from verifiers.v1.types import Messages, content_text
 from verifiers.v1.utils.generic import concrete_type
 
 if TYPE_CHECKING:
@@ -51,7 +36,9 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
-class TaskResources(StrictBaseModel):
+class TaskResources(BaseModel):
+    """Optional resource limits for the task."""
+
     model_config = ConfigDict(frozen=True)
 
     cpu: float | None = None
@@ -64,37 +51,41 @@ class TaskResources(StrictBaseModel):
     """Disk in GB (enforced by prime; advisory on docker/modal)."""
 
 
-class TaskTimeout(StrictBaseModel):
+class TaskTimeout(BaseModel):
     """Optional per-task timeout overrides, in seconds."""
 
     model_config = ConfigDict(frozen=True)
 
     setup: float | None = None
+    """Timeout (in seconds) for the task's setup hook."""
     agent: float | None = None
+    """Timeout (in seconds) for the agent's solve attempt."""
     finalize: float | None = None
+    """Timeout (in seconds) for the task's finalize hook."""
     scoring: float | None = None
+    """Timeout (in seconds) for the task's scoring."""
 
 
-class TaskData(StrictBaseModel):
-    """The task's wire half: one row's pure data, a frozen pydantic model. Subclass
-    per dataset to add typed task-specific fields next to the base fields; behavior
-    lives on `Task`, which wraps this (`self.data`)."""
-
+class TaskData(BaseModel):
     model_config = ConfigDict(frozen=True)
 
     idx: int | None = None
-    """Dataset row index — set by tasksets (selection, resume, and grouping key
-    on the eval path); `None` for ad-hoc tasks minted in scripts."""
+    """Taskset-autogenerated index."""
     name: str | None = None
+    """Optional human-readable task name."""
     description: str | None = None
+    """Optional human-readable task description."""
+
     prompt: str | Messages | None = None
-    """Initial user prompt; `None` means the user opens the conversation — run the
-    task through `agent.interaction()`, whose first `turn(message)` speaks first. (A
-    default, not just optional: the wire drops `None`s — `traces.jsonl` rows for
-    prompt-less tasks must read back.)"""
+    """Initial user prompt; unset if the user opens the conversation."""
     system_prompt: str | None = None
+    """Optional system prompt to prepend to the user prompt."""
+
     image: str | None = None
+    """Optional Docker image to use for the task. Only relevant for tasks that run in a container."""
     workdir: str | None = None
+    """Optional working directory to use for the task. Only relevant for tasks that run in a container."""
+
     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 combines with existing
@@ -103,11 +94,13 @@ class TaskData(StrictBaseModel):
     """Execution-time destinations denied by this task and combined with runtime
     blocks. Non-empty concrete allowlists cannot be combined with blocklists. Docker
     framework routes take precedence; ordinary Prime deny rules pass through unchanged."""
+
     artifacts: list[Artifact] = Field(default_factory=list)
     """Paths collected from one runtime and restored at the same locations in another,
     on top of the implicitly collected `/logs/artifacts/` convention dir. Declare
     runtime outputs that must cross that boundary. A declared path that is missing at
     collection time fails the rollout."""
+
     timeout: TaskTimeout = TaskTimeout()
     resources: TaskResources = TaskResources()
 
@@ -125,23 +118,10 @@ class WireTaskData(TaskData):
     model_config = ConfigDict(extra="allow")
 
 
-# No `default=`: an unparameterized `Trace`'s `task` field must serialize duck-typed
-# (a defaulted TypeVar narrows pydantic's serialization to the base `TaskData`, silently
-# dropping subclass fields from the wire).
 DataT = TypeVar("DataT", bound=TaskData)
 ConfigT = TypeVar("ConfigT", bound=TaskConfig, default=TaskConfig)
 
 
-def task_data_cls(cls: type) -> type[TaskData]:
-    """Resolve a task's `TaskData` specialization through its MRO, else `TaskData`."""
-    return concrete_type(cls, TaskData) or TaskData
-
-
-def task_config_cls(cls: type) -> type[TaskConfig]:
-    """Resolve a task's `TaskConfig` specialization through its MRO, else `TaskConfig`."""
-    return concrete_type(cls, TaskConfig) or TaskConfig
-
-
 def resolve_server_config(
     owner: str, config: BaseConfig, server_cls: type, *, sole: bool = True
 ) -> BaseConfig:
@@ -168,48 +148,20 @@ def resolve_server_config(
 
 
 class Task(Generic[DataT, StateT, ConfigT]):
-    """Behavior, lifecycle, servers, and scoring for one `TaskData` row.
-
-    Parameterize as `Task[MyData, MyState, MyConfig]`. Construction accepts the row
-    and an optional config; omitting config builds the declared config type. One task
-    instance is shared across a rollout group, so per-rollout state belongs on the trace.
-    """
-
     NEEDS_CONTAINER: ClassVar[bool] = False
+    """Whether the task needs a containerized environment (isolated filesystem, ...)."""
 
     tools: ClassVar[tuple[type[Toolset], ...]] = ()
 
     def __init__(self, data: DataT, config: ConfigT | None = None) -> None:
         self.data = data
-        self.config = config if config is not None else task_config_cls(type(self))()
+        self.config = config if config is not None else self.config_type()()
 
     def with_system_prompt(self, system_prompt: str) -> Self:
-        """A shallow copy of this task with `data.system_prompt` overridden. Copies the
-        instance instead of reconstructing via `type(self)(...)`, so a subclass with a
-        non-`(data, config)` constructor or extra load-time state keeps it. Used to apply the
-        config-layer / GEPA system prompt (see `TasksetConfig` and `verifiers.v1.gepa`)."""
         clone = copy.copy(self)
         clone.data = self.data.model_copy(update={"system_prompt": system_prompt})
         return clone
 
-    def plugged_judges(self) -> list[Judge]:
-        from verifiers.v1.loaders import load_judge
-
-        return [load_judge(config) for config in self.config.judges]
-
-    def server_config(self, server_cls: type) -> BaseConfig:
-        """The config a declared server class (`tools`) is built with (see
-        `resolve_server_config`). Override to pair explicitly."""
-        return resolve_server_config(
-            type(self).__name__,
-            self.config,
-            server_cls,
-            sole=len(set(type(self).tools)) == 1,
-        )
-
-    def tool_servers(self) -> list[Toolset]:
-        return [cls(self.server_config(cls)) for cls in type(self).tools]
-
     async def setup(self, trace: Trace, runtime: Runtime) -> None:
         return None
 
@@ -284,5 +236,29 @@ class Task(Generic[DataT, StateT, ConfigT]):
                 for key, value in items:
                     trace.record_reward(key, value, judge.config.weight)
 
+    @classmethod
+    def data_type(cls) -> type[TaskData]:
+        return concrete_type(cls, TaskData) or TaskData
+
+    @classmethod
+    def config_type(cls) -> type[TaskConfig]:
+        return concrete_type(cls, TaskConfig) or TaskConfig
+
+    def plugged_judges(self) -> list[Judge]:
+        from verifiers.v1.loaders import load_judge
+
+        return [load_judge(config) for config in self.config.judges]
+
+    def server_config(self, server_cls: type) -> BaseConfig:
+        return resolve_server_config(
+            type(self).__name__,
+            self.config,
+            server_cls,
+            sole=len(set(type(self).tools)) == 1,
+        )
+
+    def tool_servers(self) -> list[Toolset]:
+        return [cls(self.server_config(cls)) for cls in type(self).tools]
+
 
 TaskT = TypeVar("TaskT", bound=Task)

verifiers/v1/taskset.py

@@ -103,8 +103,6 @@ class Taskset(ABC, Generic[TaskT, TasksetConfigT]):
         return concrete_type(cls, Task, origin=Taskset) or Task
 
     def server_config(self, server_cls: type) -> BaseConfig:
-        """The config a `tools` entry is built with, resolved off `self.config` (the
-        taskset config; see `resolve_server_config`). Override to pair explicitly."""
         return resolve_server_config(
             type(self).__name__,
             self.config,

verifiers/v1/tasksets/harbor/taskset.py

@@ -22,7 +22,7 @@ from collections.abc import Iterator
 from functools import lru_cache
 from pathlib import Path
 
-from pydantic import Field
+from pydantic import BaseModel, Field
 
 from verifiers.v1.artifacts import Artifact, collect
 from verifiers.v1.configs.taskset import TasksetConfig
@@ -32,7 +32,6 @@ from verifiers.v1.runtimes import Runtime
 from verifiers.v1.task import Task, TaskData, TaskResources, TaskTimeout
 from verifiers.v1.taskset import Taskset
 from verifiers.v1.trace import Trace
-from verifiers.v1.types import StrictBaseModel
 
 CACHE = Path.home() / ".cache" / "harbor"
 HARBOR_INSTALL_HINT = "uv sync --python 3.12 --extra harbor"
@@ -73,12 +72,12 @@ class HarborConfig(TasksetConfig):
     has what the task needs (e.g. you've pointed the runtime at the right image)."""
 
 
-class Author(StrictBaseModel):
+class Author(BaseModel):
     name: str | None = None
     email: str | None = None
 
 
-class CollectHook(StrictBaseModel):
+class CollectHook(BaseModel):
     """One `[[verifier.collect]]` command, run in the agent's box by `finalize`."""
 
     command: str

verifiers/v1/trace.py

@@ -7,7 +7,7 @@ from collections.abc import Mapping
 from typing import TYPE_CHECKING, Annotated, Any, Generic, Literal
 
 import numpy as np
-from pydantic import Field, PrivateAttr
+from pydantic import BaseModel, Field, PrivateAttr
 from renderers.base import MultiModalData
 from typing_extensions import TypeVar
 
@@ -27,7 +27,6 @@ from verifiers.v1.types import (
     KeptTokens,
     Messages,
     Sampling,
-    StrictBaseModel,
     Tool,
     ToolMessage,
     Usage,
@@ -50,7 +49,7 @@ EXCLUDE_FIELDS: dict = {
 """Raw tensor fields kept on the msgpack wire but excluded from disk serialization."""
 
 
-class TimeSpan(StrictBaseModel):
+class TimeSpan(BaseModel):
     """Wall-clock timestamps with a derived, non-serialized duration in seconds."""
 
     start: float = 0.0
@@ -61,34 +60,34 @@ class TimeSpan(StrictBaseModel):
         return max(0.0, self.end - self.start) if self.end else 0.0
 
 
-class TimeSplit(StrictBaseModel):
+class TimeSplit(BaseModel):
     """Records a measured duration in seconds."""
 
     duration: float = 0.0
 
 
-class GenerationSpan(TimeSpan):
+class AgentSpan(TimeSpan):
     model: TimeSplit = Field(default_factory=TimeSplit)
     harness: TimeSplit = Field(default_factory=TimeSplit)
 
 
-class Timing(StrictBaseModel):
+class Timing(BaseModel):
     start: float = Field(default_factory=time.time)
     boot: TimeSpan = Field(default_factory=TimeSpan)
     setup: TimeSpan = Field(default_factory=TimeSpan)
-    generation: GenerationSpan = Field(default_factory=GenerationSpan)
+    agent: AgentSpan = Field(default_factory=AgentSpan)
     finalize: TimeSpan = Field(default_factory=TimeSpan)
     scoring: TimeSpan = Field(default_factory=TimeSpan)
 
 
-class Error(StrictBaseModel):
+class Error(BaseModel):
     type: str
     message: str
     status_code: int | None = None
     traceback: str | None = None
 
 
-class VersionInfo(StrictBaseModel):
+class VersionInfo(BaseModel):
     version: str
     commit: str | None = None
 
@@ -104,7 +103,7 @@ def _current_build() -> VersionInfo:
 AgentConfigT = TypeVar("AgentConfigT", bound=AgentConfig, default=AgentConfig)
 
 
-class AgentInfo(StrictBaseModel, Generic[AgentConfigT]):
+class AgentInfo(BaseModel, Generic[AgentConfigT]):
     config: AgentConfigT
     """The resolved config that rebuilds the agent (`Agent(trace.agent.config)`)."""
     runtime: RuntimeInfo | None = None
@@ -115,7 +114,7 @@ class AgentInfo(StrictBaseModel, Generic[AgentConfigT]):
     """Whether this trace's tokens train the run's policy."""
 
 
-class TraceTask(StrictBaseModel, Generic[DataT]):
+class TraceTask(BaseModel, Generic[DataT]):
     """The task as recorded on the trace, self-describing without the run's config."""
 
     type: str
@@ -124,7 +123,7 @@ class TraceTask(StrictBaseModel, Generic[DataT]):
     """The (immutable) row being solved."""
 
 
-class Reward(StrictBaseModel):
+class Reward(BaseModel):
     score: float
     weight: float = 1.0
 
@@ -133,14 +132,14 @@ class Reward(StrictBaseModel):
         return self.score * self.weight
 
 
-class EvalRunInfo(StrictBaseModel):
+class EvalRunInfo(BaseModel):
     type: Literal["eval"] = "eval"
 
     id: str
     step: int | None = None
 
 
-class TrainRunInfo(StrictBaseModel):
+class TrainRunInfo(BaseModel):
     type: Literal["train"] = "train"
 
     id: str
@@ -151,7 +150,7 @@ RunInfo = Annotated[EvalRunInfo | TrainRunInfo, Field(discriminator="type")]
 """The run a trace belongs to, discriminated on `type`."""
 
 
-class ModelCall(StrictBaseModel):
+class ModelCall(BaseModel):
     """A model call, automatically recorded at intercept time."""
 
     node: int | None = None
@@ -172,7 +171,7 @@ class ModelCall(StrictBaseModel):
     """The failure that ended this call, coupled to the exchange that caused it."""
 
 
-class Branch(StrictBaseModel):
+class Branch(BaseModel):
     """A root-to-leaf graph path; each branch becomes one training sample."""
 
     index: int
@@ -298,7 +297,7 @@ class Branch(StrictBaseModel):
         return self.num_total_tokens - self.num_output_tokens
 
 
-class Trace(StrictBaseModel, Generic[DataT, StateT, AgentConfigT]):
+class Trace(BaseModel, Generic[DataT, StateT, AgentConfigT]):
     version: int = TRACE_VERSION
     """The trace schema this trace serializes as."""
     id: str = Field(default_factory=lambda: uuid.uuid4().hex)
@@ -492,14 +491,14 @@ class Trace(StrictBaseModel, Generic[DataT, StateT, AgentConfigT]):
         if self.stop_condition is None:
             self.stop_condition = condition
 
-    def split_generation(self) -> None:
-        """Split the generation span into model and harness time."""
-        gen = self.timing.generation
-        if not gen.end:
+    def split_agent_time(self) -> None:
+        """Split the agent span into model and harness time."""
+        span = self.timing.agent
+        if not span.end:
             return
         model = sum(call.time.duration for call in self.calls)
-        gen.model.duration = min(model, gen.duration)
-        gen.harness.duration = gen.duration - gen.model.duration
+        span.model.duration = min(model, span.duration)
+        span.harness.duration = span.duration - span.model.duration
 
     def record_error(self, error: Exception) -> None:
         """Record an error, and stop the trace as failed."""

verifiers/v1/types.py

@@ -7,20 +7,16 @@ from renderers.base import MultiModalData
 from typing_extensions import TypedDict
 
 
-class StrictBaseModel(BaseModel):
-    model_config = ConfigDict(extra="forbid")
-
-
-class TextContentPart(StrictBaseModel):
+class TextContentPart(BaseModel):
     type: Literal["text"] = "text"
     text: str
 
 
-class ImageUrlSource(StrictBaseModel):
+class ImageUrlSource(BaseModel):
     url: str
 
 
-class ImageUrlContentPart(StrictBaseModel):
+class ImageUrlContentPart(BaseModel):
     type: Literal["image_url"] = "image_url"
     image_url: ImageUrlSource
 
@@ -57,24 +53,24 @@ def content_text(content: "MessageContent | None") -> str:
     )
 
 
-class SystemMessage(StrictBaseModel):
+class SystemMessage(BaseModel):
     role: Literal["system"] = "system"
     content: MessageContent
 
 
-class UserMessage(StrictBaseModel):
+class UserMessage(BaseModel):
     role: Literal["user"] = "user"
     content: MessageContent
 
 
-class ToolCall(StrictBaseModel):
+class ToolCall(BaseModel):
     id: str
     name: str
     arguments: str
     """Raw JSON string of arguments, exactly as the model emitted it."""
 
 
-class AssistantMessage(StrictBaseModel):
+class AssistantMessage(BaseModel):
     role: Literal["assistant"] = "assistant"
     content: str | None = None
     reasoning_content: str | None = None
@@ -83,7 +79,7 @@ class AssistantMessage(StrictBaseModel):
     """Opaque native items replayed to preserve signed or encrypted reasoning state."""
 
 
-class ToolMessage(StrictBaseModel):
+class ToolMessage(BaseModel):
     role: Literal["tool"] = "tool"
     tool_call_id: str
     content: MessageContent
@@ -98,7 +94,7 @@ Message = Annotated[
 Messages = list[Message]
 
 
-class Tool(StrictBaseModel):
+class Tool(BaseModel):
     name: str
     description: str
     parameters: dict[str, Any]
@@ -108,7 +104,7 @@ class Tool(StrictBaseModel):
 FinishReason = Literal["stop", "length", "tool_calls"] | None
 
 
-class Usage(StrictBaseModel):
+class Usage(BaseModel):
     """Provider token accounting.
 
     `prompt_tokens` excludes cache reads; `input_tokens` adds them back. Reasoning tokens
@@ -191,10 +187,10 @@ class KeptTokens:
     counts: Any
 
 
-class TurnTokens(StrictBaseModel):
+class TurnTokens(BaseModel):
     """Training tokens from renderer tokenization or provider-returned token IDs."""
 
-    model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True)
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
     prompt_ids: list[int] = Field(default_factory=list)
     completion_ids: list[int] = Field(default_factory=list)
@@ -220,7 +216,7 @@ class TurnTokens(StrictBaseModel):
     kept_tokens: KeptTokens | None = Field(default=None, exclude=True)
 
 
-class Response(StrictBaseModel):
+class Response(BaseModel):
     id: str
     created: int
     model: str

{verifiers-0.2.2.dev53.dist-info → verifiers-0.2.2.dev55.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: verifiers
-Version: 0.2.2.dev53
+Version: 0.2.2.dev55
 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.dev53.dist-info → verifiers-0.2.2.dev55.dist-info}/RECORD

@@ -167,42 +167,42 @@ verifiers/utils/threaded_sandbox_client.py,sha256=XRzYhWBpMev7kw_aNMWAy6lfa-9uAn
 verifiers/utils/tool_utils.py,sha256=gInWZODWQUZN4TyEMuuITyOUm9qlHJxtcvr1zZl_zJs,1020
 verifiers/utils/usage_utils.py,sha256=Mw6WC78r6EsLyRFdP9ICveqptkjizbSkAC86ZH0geVU,3918
 verifiers/utils/version_utils.py,sha256=39gV8-mNF9GspAgKloLo8oy7_MVluMrwGPrntQv2hx4,2656
-verifiers/v1/__init__.py,sha256=uqq1Jzek51cYa2TyHqzDwU6zlOmD3wKLF063Kjh_iN0,7521
+verifiers/v1/__init__.py,sha256=Im5qTZy9mH6PRTUi-1V6W7EWKZzJyTWLGKMYALbWz_w,7467
 verifiers/v1/agent.py,sha256=dj4GabQSs6Wzwbph5Rlx-efsVQsSuWV2YI5hfvq5mGA,31990
-verifiers/v1/artifacts.py,sha256=G-YTfTAYA35zxKzM-jK60TprndfQevPA65hWDw6ae7Y,5877
+verifiers/v1/artifacts.py,sha256=5eKOjDSUWwj7GrhxILMHdz2ngEONWMdcTGlBcuGgrLU,5834
 verifiers/v1/decorators.py,sha256=9CcCwgZlRjVGPqT5G1CFJUHP4OIMuBGkUJZkcI6dnbk,3865
-verifiers/v1/env.py,sha256=m-1TNzs9YyFbMkoW6c54vI5xG4jnW3LvLgvJhOgbg04,18447
-verifiers/v1/episode.py,sha256=KWyM9ovTphEIo2260BYu2HvtnOOTxjLRDPrF_jTCiuA,2497
+verifiers/v1/env.py,sha256=a7cKeecsm4d1lZPhRJy-m7FFWHrHF2msOdqma7o5I6M,18468
+verifiers/v1/episode.py,sha256=YtuRTV_PpwDglXFeN6UNg8IswpP1HseFLCYtascGMNI,3218
 verifiers/v1/errors.py,sha256=slZnrtqMo_BgXQV46wJJhV6vvAAnVsuCbVGp2vBVWfs,6888
-verifiers/v1/graph.py,sha256=-j8MNdIv1r5ifajv5ggnGPsfBNB74IO3WKLcrpYh9hg,29102
+verifiers/v1/graph.py,sha256=aBAzh1Ibp3klKNYjvzNyJSbjV8Oi5TJ791dN7o6ex1E,29070
 verifiers/v1/harness.py,sha256=cDiDuhp29aqL4CxiqSZz-IT0QlOcVlye_vTTHZblWo8,10948
-verifiers/v1/judge.py,sha256=duZcWYTynzqShs8vfbExpFlgLS-JA9NFqdmCRLg3sbc,9393
-verifiers/v1/legacy.py,sha256=nkbdhFJZN1QzsjE42AB_A_c1zrk3_Y8zR07srZJS2ck,22584
+verifiers/v1/judge.py,sha256=hISmuXidKCMROni9_4q4I-EeoO_uEieafGd2WBjRNKM,9338
+verifiers/v1/legacy.py,sha256=ISk3Bix9Hy5EjZtyV9QO0LNyDNDklBHVjFokOrw_3U8,22628
 verifiers/v1/loaders.py,sha256=NSIBdNU3JVeyddL-dM4dJt6khCHyjCgzJuFtLrgiwD0,9989
 verifiers/v1/push.py,sha256=MWZmvyj0iyzNIO0xRhlkCXtFF1plq6EJi8rWlvrFtvI,11363
 verifiers/v1/retries.py,sha256=quUGVruUkZx-9WQcFiocMfL_M056voU8gwDqsuLR3f4,5412
-verifiers/v1/rollout.py,sha256=GJzHgJFlw8O1vDtWM__2JhSiG2GqbfjtH2ri1MRfw3g,20495
+verifiers/v1/rollout.py,sha256=pmF4sgyHDRUUTnOxOWgBsPP8x6L_KFGaeR_dDKziANs,20470
 verifiers/v1/scoring.py,sha256=-R5Cog14r_tJ6Q_oOfGr5VPAm2CCUhofYZB6B9lm4wM,5787
 verifiers/v1/session.py,sha256=J6ZPuvsg6vMTJAs9dMUMtfdjCuvp6Hom877DVdKFKlY,6912
-verifiers/v1/state.py,sha256=mcQBl9ItRPVrcVr7YzHLbEqKdDSfybhtWD8XDEkeui0,717
-verifiers/v1/task.py,sha256=Ofd3Sh8bfFeEy6nhgeHV0CT2-9lAoGypQyVYhtSP1oc,12206
-verifiers/v1/taskset.py,sha256=RPFkpRkeEyPX557_mK-JwraBuUKsguiCUKSFyotTclU,4636
-verifiers/v1/trace.py,sha256=9KqBeGaRUtWh6Gpdf6G1c7UZso0DB9Mjmtkzl6I_oYE,19458
-verifiers/v1/types.py,sha256=5tZyG4r4bLJ9a14oybHy7bSCpt5X5A17eRwmIszuRo8,9118
+verifiers/v1/state.py,sha256=pcpN2V6tX7rIO5XdtdUYay1j0ktEwrMtq7w1ApfsPdE,675
+verifiers/v1/task.py,sha256=pM2S4YU56jTuvvwHe00r1pBupQ42pvMUzpQhUXqpAPk,10232
+verifiers/v1/taskset.py,sha256=5ffTlnmiN2GDePhonGSJ1a7iTseLPOC0DkwaVwf7uY4,4465
+verifiers/v1/trace.py,sha256=_bGHOrE6fRLGm0JYc0PrrrO3lyr-qqOF5Y1bHfViwR0,19347
+verifiers/v1/types.py,sha256=1PxamJspmoTc3OlFZAwH6o_2i_Tg9ZNvHxttIHWIxq8,8948
 verifiers/v1/acp/__init__.py,sha256=9dwH6fLopNndRmcpRSYC8ghzzMquaLfgh645QM-Dwic,2189
 verifiers/v1/acp/_runner.py,sha256=FqEnHR0Q_YrCt_EuaJqiqTpd2_kFa41FqcEunwOhvTI,6856
 verifiers/v1/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-verifiers/v1/cli/debug.py,sha256=mRBPlYjc93o-4sooVSJXl_H3zALC2vhAl3EBzN-DpoM,11507
+verifiers/v1/cli/debug.py,sha256=-jeEV_Q5tV8SOkWc1GdPZcXZWON_jU5gjeO4YoZm79o,11482
 verifiers/v1/cli/gepa.py,sha256=hLIbS_4jBx0vvy4PXoePR5riFXcNvzQCMixZ-g2OR_U,4026
 verifiers/v1/cli/init.py,sha256=dVpX1YMz7DFmHgskAsPjP-HmVTGoZfC0ZUyE-T4I6l0,8322
 verifiers/v1/cli/output.py,sha256=pMS5Z0EBgyAVShNCAk9jVURNeLOaTfeRWpt0J8hHjq8,5890
-verifiers/v1/cli/replay.py,sha256=Jjyi61fl20xjGArdXTwZ3qKoSkC0iQ6WLSrvKkURdeI,10179
+verifiers/v1/cli/replay.py,sha256=DAh9kB5PB-ppZLGhxdJwrCPch_Yky5HKhplwGFhKEz0,10164
 verifiers/v1/cli/resolve.py,sha256=OsNw4C3r9xOVFa-mminJFcex_bAsJ6EQ8K7A_H8u2kQ,4370
 verifiers/v1/cli/serve.py,sha256=_mdJaHVVe4pXzcpAot0ugcmiN3ra2gS4GrGmLghnX5M,2866
 verifiers/v1/cli/validate.py,sha256=lZ_wWnLgIWH5rUlMtwzvF3uS_cFZA4ZqBowpzdI4gos,10260
 verifiers/v1/cli/dashboard/__init__.py,sha256=v-baMxQuWxOCsbU7-p_jj2Q9BUnTN-TWi1q2hK6rU2s,198
 verifiers/v1/cli/dashboard/base.py,sha256=kUP93zJSIVLptSbnWX6MOy8kGg63fpeAzPqakCpPyDc,3547
-verifiers/v1/cli/dashboard/eval.py,sha256=i_Qn9enCU7aas-VTVAJocPNbTuHSUHThwQnls-3_kc4,34265
+verifiers/v1/cli/dashboard/eval.py,sha256=QJlBKRvEaxBYWZ-WQQfJqaBZoVDIO3MnJnzeD3VusEI,33436
 verifiers/v1/cli/dashboard/replay.py,sha256=CvRVaf0dUum5v0IzPQbFPPikBQmTrkMeaunGfVMTWHc,2755
 verifiers/v1/cli/dashboard/validate.py,sha256=rLsQ_31DjTIZpC_VO7zSG41ncUEBxqCx8mL9nTnGiMc,3650
 verifiers/v1/cli/eval/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -239,7 +239,7 @@ verifiers/v1/dialects/chat.py,sha256=R_otqi5N0snB1QVKIYloNeLHR9kc7OmI06HYg1ir_Lw
 verifiers/v1/dialects/responses.py,sha256=ismnxUikPcPUIm80FUTPBbj-Cn1e0yGAsISMEseAWRc,13679
 verifiers/v1/envs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 verifiers/v1/envs/agentic_judge/__init__.py,sha256=6vwtMCQ_cuvuubCF5-nrE5W7gGgzE-LIPKorkM5DXdw,309
-verifiers/v1/envs/agentic_judge/env.py,sha256=NEv1AUbOrGSFDJNzMVmAUkNVk89L1Cpyu36Ndrg3xFI,17003
+verifiers/v1/envs/agentic_judge/env.py,sha256=QRYxs8M5ivk7jnEwPgYfCLVZTBQOuSc64xydoBixXDs,16961
 verifiers/v1/envs/best_of_n/__init__.py,sha256=mubASiwXMNIhnQFDccNAc7yZ0OFsOVK8hH8WIx9b2A4,119
 verifiers/v1/envs/best_of_n/env.py,sha256=KEUJBCVqblnXP_lEwm3mjGdaikBMkecz8UjOFPBhxc0,1987
 verifiers/v1/envs/single_agent/__init__.py,sha256=r0edAc_6gtHBhPzeBGVcdHZZqSdCPZnLMje6eVgyz5U,138
@@ -288,7 +288,7 @@ verifiers/v1/interception/tunnel/prime.py,sha256=K2n2daP_iNoO-087owAYHBkR7z0PBNn
 verifiers/v1/judges/__init__.py,sha256=MUIBWcx6c70BykrTDHhB0ITIyJPxXe6xDBou4VM7jDQ,286
 verifiers/v1/judges/reference.py,sha256=iEVHw-iJ6dbwLOOqrvWrEMJOcUEYJ0YspT04rZz7Sd4,3868
 verifiers/v1/judges/reference.txt,sha256=Ej35kGXiT2uJ0LcHIeez49rCS_9uHmCQKoVdn93V6A8,353
-verifiers/v1/judges/rubric.py,sha256=kB0yWEtfC60zJBCVjOKBO00YtH8-AOofzPkuyccVTtQ,11940
+verifiers/v1/judges/rubric.py,sha256=PglrJhMQR6scFyfz20jVlLQEzeqXKV2P6r0K0K7jjBE,11916
 verifiers/v1/judges/rubric.txt,sha256=3KA2ZeYYdcDweJhUGopxu9EFgARhu2aWft5S5cj8Bc8,323
 verifiers/v1/mcp/__init__.py,sha256=pm8ZWBiL1q1tY4wHvJzM_QrZ9oR8aGm-bIRWiRJsgHI,408
 verifiers/v1/mcp/launch.py,sha256=lRtcl98BO7imC44bsxO2yljwRQR_KCvJ6P-bd_hS5L8,18444
@@ -305,11 +305,11 @@ verifiers/v1/runtimes/docker/egress.py,sha256=37UXgNX9gnoLxjMg4KZaJIGoApCAM6MK22
 verifiers/v1/serve/__init__.py,sha256=sr_zkDzAHnOcQm-QRm8xwJBmCMFD-xhKIFPaDZvMbUs,641
 verifiers/v1/serve/client.py,sha256=amUhf4cFJ1xCb8kw_AoVviwN543Wknx8LzImq1ZpaiQ,7057
 verifiers/v1/serve/pool.py,sha256=e9Nc3nQKEyV9YqyKHl_RuqQ84zWVa8z2J1rc3rfCadM,14828
-verifiers/v1/serve/server.py,sha256=VBOD3Gzq4p0ZD_8xgtG039i3JaefhOH0MmR6cxG56iY,9705
+verifiers/v1/serve/server.py,sha256=IfJunpYX3MmNDToEcY-QHxDGfbZnK2i3C1-sgft6xfw,9687
 verifiers/v1/serve/types.py,sha256=y8Cf9wKOZRKDXcThFWVygTFHITJofOinGiIzwjQGCUE,2674
 verifiers/v1/tasksets/__init__.py,sha256=b62O4WDNbGfJH_4NjYmznn5otWovdfvUgJZyoIZyLh8,596
 verifiers/v1/tasksets/harbor/__init__.py,sha256=wwVGA8N7E2Q2qA5WGHuLRrn4DgG5oaRHrCS2RW3NXVY,195
-verifiers/v1/tasksets/harbor/taskset.py,sha256=pkXYS1vknI66SXQV86ypUEZ4kCBdVH2QjMuGjWt8UC0,18283
+verifiers/v1/tasksets/harbor/taskset.py,sha256=w7o7yGM-FmvLEW4zNvwutvOX4n9cq8eQWwb7WxUYtSA,18235
 verifiers/v1/tasksets/lean/__init__.py,sha256=oyv-GbJQBvCyGwo7Ysxm2NjZW-aX4j1uDoHU0f-E7xQ,767
 verifiers/v1/tasksets/lean/scoring.py,sha256=sfzsT6MUK0zdMgAQ57_P_0CBaPHy3M7go71QMr5hDrs,10599
 verifiers/v1/tasksets/lean/taskset.py,sha256=Fcn4UgTcdjMYnJ4CThaFZ28Rz_QDx0e21vJdW_vp12g,9019
@@ -330,8 +330,8 @@ verifiers/v1/utils/logging.py,sha256=OcMHA6NsYux3oIzjPuI95rDWmFBHNcHDjZeNIhXTX-Y
 verifiers/v1/utils/memory.py,sha256=ZkIvGk6uITAH5sKon65LifKPbvZr8mJ__PVc23FZpOQ,1835
 verifiers/v1/utils/sampling.py,sha256=52TJ5-Hmpvp4YSgKNR-LmAPVwm4RDcH-o2-BnbVTmYQ,965
 verifiers/v1/utils/version.py,sha256=-obEo_-l9-D8FLef4hYxncOe-uJpxrM1g2Hig_37Sgs,1607
-verifiers-0.2.2.dev53.dist-info/METADATA,sha256=vvfSCIqaWIr6egUCiFZ505i0TPbN5Cc0boYECWJ-sMg,4545
-verifiers-0.2.2.dev53.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-verifiers-0.2.2.dev53.dist-info/entry_points.txt,sha256=dF82JUYEFslR1AOW8LZfuBWeZeQoyX4wCRrduklg8-I,551
-verifiers-0.2.2.dev53.dist-info/licenses/LICENSE,sha256=v0RrUsdV3IDoZhrRce297IXS3xMHNJ-_LdLpFAUWb9k,1072
-verifiers-0.2.2.dev53.dist-info/RECORD,,
+verifiers-0.2.2.dev55.dist-info/METADATA,sha256=Jcl9dMFMROAPjPXzDCMNCz_r43jDq4Xp2QjEZZ0Z9b4,4545
+verifiers-0.2.2.dev55.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+verifiers-0.2.2.dev55.dist-info/entry_points.txt,sha256=dF82JUYEFslR1AOW8LZfuBWeZeQoyX4wCRrduklg8-I,551
+verifiers-0.2.2.dev55.dist-info/licenses/LICENSE,sha256=v0RrUsdV3IDoZhrRce297IXS3xMHNJ-_LdLpFAUWb9k,1072
+verifiers-0.2.2.dev55.dist-info/RECORD,,