verifiers 0.2.2.dev42__py3-none-any.whl → 0.2.2.dev44__py3-none-any.whl

verifiers/v1/__init__.py

@@ -14,16 +14,18 @@ from verifiers.v1.clients import (
     resolve_client,
 )
 from verifiers.v1.configs.agent import AgentConfig
-from verifiers.v1.configs.cli.env import (
-    ElasticPoolConfig,
-    EnvServerConfig,
-    StaticPoolConfig,
-    pool_serve_kwargs,
-)
+from verifiers.v1.configs.cli.env import narrowed_env_annotation, resolve_env_field
 from verifiers.v1.configs.env import EnvConfig, default_agent_harness
 from verifiers.v1.configs.harness import HarnessConfig
 from verifiers.v1.configs.judge import JudgeConfig, Judges
+from verifiers.v1.configs.legacy import LegacyEnvConfig
 from verifiers.v1.configs.retries import RetryConfig
+from verifiers.v1.configs.serve import (
+    ElasticPoolConfig,
+    ServingConfig,
+    StaticPoolConfig,
+    pool_serve_kwargs,
+)
 from verifiers.v1.configs.task import TaskConfig
 from verifiers.v1.configs.taskset import TasksetConfig
 from verifiers.v1.decorators import metric, reward, stop, tool
@@ -248,7 +250,10 @@ __all__ = [  # noqa: RUF022 - grouped by public API area
     "Env",
     "SingleAgentEnv",
     "EnvConfig",
-    "EnvServerConfig",
+    "ServingConfig",
+    "LegacyEnvConfig",
+    "resolve_env_field",
+    "narrowed_env_annotation",
     "SingleAgentEnvConfig",
     "AgentConfig",
     "StaticPoolConfig",

verifiers/v1/agent.py

@@ -276,9 +276,9 @@ class Agent:
             max_total_tokens=config.max_total_tokens,
         )
         self.timeout = config.timeout
-        # Env episode agents replace this with the eval concurrency semaphore.
-        # Interactions acquire it only around active lifecycle work, never while
-        # awaiting the caller between segments.
+        # Env episode agents replace this with the episode's agent semaphore
+        # (`--env.max-concurrent-agents`). Interactions acquire it only around active
+        # lifecycle work, never while awaiting the caller between segments.
         self._gate: asyncio.Semaphore | None = None
         # Env-owned standing, not config: `Env.setup` marks fixed agents
         # untrainable and traces are stamped from here; inert outside an env.
@@ -578,9 +578,9 @@ class _EpisodeAgent(Agent):
     bundle of references — expensive resources are env-owned and borrowed, so no
     state spans concurrent episodes): traces get their agent standing the moment
     they're created, finished ones land in `completed` (the episode's traces),
-    each run takes the eval's gate. The taskset's shared tool servers ride only
-    its own tasks — on an env-minted task they'd wrongly put MCP in play
-    (`tools=` overrides)."""
+    each run takes one of the episode's agent permits. The taskset's shared tool
+    servers ride only its own tasks — on an env-minted task they'd wrongly put MCP
+    in play (`tools=` overrides)."""
 
     def __init__(
         self,
@@ -664,8 +664,9 @@ class _EpisodeAgent(Agent):
         """The agent's `interaction`, with every trace stamped with its standing
         at mint and captured in `completed` at close — an interaction driven from
         `Env.run` stays crash-safe. Setup, each active segment, and close acquire
-        the eval gate independently; the interaction holds no permit while awaiting
-        its caller, so peer interactions can interleave even at concurrency one."""
+        an agent permit independently; the interaction holds no permit while awaiting
+        its caller, so peer interactions still interleave where an episode plays one
+        agent at a time."""
         trace: Trace | None = None
 
         def remember(current: Trace) -> None:

verifiers/v1/cli/dashboard/eval.py

@@ -95,7 +95,7 @@ def _limits(config: EvalConfig) -> list[str]:
             toks.append(f"{label}≤{v}")
     turns = _seat_value(config, lambda spec: spec.max_turns)
     return [
-        f"≤{config.max_concurrent} concurrent"
+        f"≤{config.max_concurrent} episodes"
         if config.max_concurrent
         else "no concurrency cap",
         "per-seat turn caps"

verifiers/v1/cli/eval/main.py

@@ -24,7 +24,7 @@ from verifiers.v1.utils.logging import setup_logging
 logger = logging.getLogger(__name__)
 
 USAGE = (
-    "usage: uv run eval [<taskset-id>] [--env.id <id>] [--id <env-id> (legacy)] [options] [@ file.toml]\n"
+    "usage: uv run eval [<taskset-id>] [--env.id <id>] [--legacy.id <env-id> (v0)] [options] [@ file.toml]\n"
     "       uv run eval --resume <output-dir>   (re-run a previous run's missing/errored rollouts)"
 )
 
@@ -49,12 +49,14 @@ def main(argv: list[str] | None = None) -> None:
             )
         config = load_resume_config(resume_dir)
     else:
-        legacy_id = any(a == "--id" or a.startswith("--id=") for a in argv)  # v0 env id
-        # An env-block flag (or a retired flat axis) skips the usage gate so the
-        # typed parse renders its did-you-mean / pointer to the new flags instead
-        # of a bare usage line.
+        legacy_id = any(
+            a == "--legacy.id" or a.startswith("--legacy.id=") for a in argv
+        )
+        # An env-block flag (or a since-moved flat axis) skips the usage gate so the
+        # typed parse renders its did-you-mean instead of a bare usage line.
         typed_axis = any(
-            a.startswith(("--env.", "--taskset.", "--harness.")) for a in argv
+            a.startswith(("--env.", "--taskset.", "--harness.", "--serve."))
+            for a in argv
         )
         if (
             not extract_id(argv, "env.taskset")
@@ -64,7 +66,7 @@ def main(argv: list[str] | None = None) -> None:
         ):
             raise SystemExit(
                 USAGE
-            )  # need a taskset (positional / --env.taskset.id), a legacy --id, or a @ file.toml
+            )  # need a taskset (positional / --env.taskset.id), a v0 --legacy.id, or a @ file.toml
 
         with plugin_errors():
             config_type = narrow_config(EvalConfig, argv)

verifiers/v1/cli/eval/runner.py

@@ -107,19 +107,24 @@ async def run_eval_server(config: EvalConfig) -> list[Episode]:
     import multiprocessing as mp
     from functools import partial
 
-    from verifiers.v1.configs.cli.env import pool_serve_kwargs
+    from verifiers.v1.configs.serve import pool_serve_kwargs
     from verifiers.v1.serve import EnvClient, env_config_data, serve_env
     from verifiers.v1.utils.logging import setup_logging
 
     legacy = config.is_legacy
     server_kwargs = (
         {
-            "env_id": config.id,
-            "env_args": config.args,
-            "extra_env_kwargs": config.extra_env_kwargs,
+            "env_id": config.legacy.id,
+            "env_args": config.legacy.args,
+            "extra_env_kwargs": config.legacy.extra_env_kwargs,
         }
         if legacy
-        else {"config_data": env_config_data(config.env)}  # picklable across the spawn
+        else {
+            "config_data": env_config_data(config.env),  # picklable across the spawn
+            # `-c` seeds each worker's episode bound unless `[serve]` pins one — so a
+            # pool carries `workers * bound` episodes, as `multiplex` implies.
+            "max_concurrent": config.worker_max_concurrent,
+        }
     )
     tasks = []
     if not legacy:
@@ -142,7 +147,7 @@ async def run_eval_server(config: EvalConfig) -> list[Episode]:
     proc = mpctx.Process(
         target=serve_env,
         kwargs=dict(
-            **pool_serve_kwargs(config.pool),
+            **pool_serve_kwargs(config.serve.pool),
             legacy=legacy,
             address="tcp://127.0.0.1:0",
             address_queue=address_queue,
@@ -210,7 +215,7 @@ async def run_eval_server(config: EvalConfig) -> list[Episode]:
                 "running %dx%d rollouts via the env-server %s pool on %s",
                 len(plan),
                 config.num_rollouts,
-                config.pool.type,
+                config.serve.pool.type,
                 config.model,
             )
         logger.info("results: %s", out)

verifiers/v1/cli/serve.py

@@ -12,12 +12,12 @@ from verifiers.v1.cli.resolve import (
     references_config_file,
     with_positional_taskset,
 )
-from verifiers.v1.configs.cli.env import pool_serve_kwargs
 from verifiers.v1.configs.cli.serve import ServeConfig
+from verifiers.v1.configs.serve import pool_serve_kwargs
 from verifiers.v1.serve import serve_env
 from verifiers.v1.utils.logging import setup_logging
 
-USAGE = "usage: uv run serve [<taskset-id>] [--env.id <id>] [--id <env-id> (legacy)] [options] [@ file.toml]"
+USAGE = "usage: uv run serve [<taskset-id>] [--env.id <id>] [--legacy.id <env-id> (v0)] [options] [@ file.toml]"
 
 
 def main(argv: list[str] | None = None) -> None:
@@ -29,11 +29,12 @@ def main(argv: list[str] | None = None) -> None:
         with plugin_errors():
             cli(narrow_config(ServeConfig, argv))
         return
-    legacy_id = any(a == "--id" or a.startswith("--id=") for a in argv)  # v0 env id
-    # An env-block flag (or a retired flat axis) skips the usage gate so the typed
-    # parse renders its did-you-mean / pointer to the new flags instead of a bare
-    # usage line.
-    typed_axis = any(a.startswith(("--env.", "--taskset.", "--harness.")) for a in argv)
+    legacy_id = any(a == "--legacy.id" or a.startswith("--legacy.id=") for a in argv)
+    # An env-block flag (or a since-moved flat axis) skips the usage gate so the typed
+    # parse renders its did-you-mean instead of a bare usage line.
+    typed_axis = any(
+        a.startswith(("--env.", "--taskset.", "--harness.", "--serve.")) for a in argv
+    )
     if (
         not extract_id(argv, "env.taskset")
         and not legacy_id
@@ -42,7 +43,7 @@ def main(argv: list[str] | None = None) -> None:
     ):
         raise SystemExit(
             USAGE
-        )  # need a taskset (positional / --env.taskset.id), a legacy --id, or @ file.toml
+        )  # need a taskset (positional / --env.taskset.id), a v0 --legacy.id, or @ file.toml
 
     with plugin_errors():
         config_type = narrow_config(ServeConfig, argv)
@@ -60,17 +61,19 @@ def main(argv: list[str] | None = None) -> None:
     # in each one.
     server_kwargs = (
         {
-            "env_id": config.id,
-            "env_args": config.args,
-            "extra_env_kwargs": config.extra_env_kwargs,
+            "env_id": config.legacy.id,
+            "env_args": config.legacy.args,
+            "extra_env_kwargs": config.legacy.extra_env_kwargs,
         }
         if config.is_legacy
-        else {"config": config.env}
+        # `--serve.max-concurrent` is each v1 worker's episode bound; the legacy
+        # bridge has never had one.
+        else {"config": config.env, "max_concurrent": config.serve.max_concurrent}
     )
     serve_env(
-        **pool_serve_kwargs(config.pool),
+        **pool_serve_kwargs(config.serve.pool),
         legacy=config.is_legacy,
-        address=config.address,
+        address=config.serve.address,
         log_setup=partial(setup_logging, level),
         **server_kwargs,
     )

verifiers/v1/configs/cli/env.py

@@ -1,35 +1,30 @@
-"""Run-config plumbing around the `[env]` block: narrowing the `env` field of the
-configs that own one, and how a served env sizes its worker pool."""
+"""Run-config plumbing around the `[env]` block: narrowing the `env` field of every
+config that owns one, and the retired keys such a config refuses.
 
-from typing import Annotated, Literal
+A run composes the blocks it needs — `[env]` (what runs, `configs/env.py`),
+`[serve]` (how it's hosted, `configs/serve.py`), `[legacy]` (the v0 bridge,
+`configs/legacy.py`) — plus its own fields. Nothing here is a base class: the eval
+CLI, the `serve` CLI, GEPA and a trainer each declare their blocks and call these.
 
-from pydantic import Field, SerializeAsAny, ValidationError, model_validator
+Declare the env field as `SerializeAsAny[EnvConfig] = Field(default_factory=
+single_agent_env_config)`. The `SerializeAsAny` is load-bearing: pydantic serializes
+by declared type, so a plain `EnvConfig` silently drops a narrowed subclass's agents
+and knobs from `model_dump()` — the env-server wire's payload."""
+
+from pydantic import ValidationError
 from pydantic_config import BaseConfig
 
 from verifiers.v1.configs.env import EnvConfig
-from verifiers.v1.types import ID
 from verifiers.v1.utils.generic import prefix_validation_error
 
 
 def resolve_env_field(data: dict, narrowed: "type[EnvConfig] | None" = None) -> dict:
-    """Shared `mode="before"` body for every run config owning an `env` field
-    (`EnvServerConfig`, `GEPAConfig`): refuse the retired top-level axes with a
-    pointer home, and narrow `env` to the concrete env's config class. `narrowed`
-    is the annotation the CLI pre-resolved (`narrow_config`) — its id is
-    authoritative, so validate against it directly."""
+    """Shared `mode="before"` body for every run config owning an `env` field: narrow
+    `env` to the concrete env's config class. `narrowed` is the annotation the CLI
+    pre-resolved (`narrow_config`) — its id is authoritative, so validate against it
+    directly."""
     if not isinstance(data, dict):
         return data
-    if "taskset" in data:
-        raise ValueError(
-            "the taskset lives on the env now: --env.taskset.id <id> "
-            "(TOML: [env.taskset]), or the positional `eval <taskset-id>`"
-        )
-    if "harness" in data:
-        raise ValueError(
-            "a harness belongs to an agent now: --env.agent.harness.* on the "
-            "single-agent env, --env.<agent>.harness.* on a multi-agent one "
-            "(TOML: [env.agent.harness])"
-        )
     raw = data.get("env")
     if raw is None:
         return data
@@ -63,105 +58,3 @@ def narrowed_env_annotation(cls) -> "type[EnvConfig] | None":
     ):
         return annotation
     return None
-
-
-class StaticPoolConfig(BaseConfig):
-    """Fixed env-server pool: pre-spawn `num_workers` workers up front."""
-
-    type: Literal["static"] = "static"
-    num_workers: int = Field(4, ge=1)
-    """Worker processes to pre-spawn (1 = a single in-process server, no pool)."""
-
-
-class ElasticPoolConfig(BaseConfig):
-    """Elastic env-server pool: start at one worker and scale up on demand."""
-
-    type: Literal["elastic"] = "elastic"
-    max_workers: int | None = None
-    """Upper bound on workers (None = unbounded)."""
-    multiplex: int = Field(128, ge=1)
-    """Rollouts per worker for the scale-up trigger: add a worker once in-flight rollouts
-    reach 90% of `workers * multiplex`."""
-
-
-# Discriminated on `type` so the CLI selects with `--pool.type static|elastic`.
-PoolConfig = Annotated[
-    StaticPoolConfig | ElasticPoolConfig, Field(discriminator="type")
-]
-
-
-def pool_serve_kwargs(pool: StaticPoolConfig | ElasticPoolConfig) -> dict:
-    """Unpack a pool config into `serve_env` kwargs (`max_workers` / `multiplex` / `elastic`)."""
-    if isinstance(pool, ElasticPoolConfig):
-        return {
-            "max_workers": pool.max_workers,
-            "multiplex": pool.multiplex,
-            "elastic": True,
-        }
-    return {"max_workers": pool.num_workers, "elastic": False}
-
-
-def _single_agent_env_config() -> EnvConfig:
-    """The default `env` block: the single-agent shape. Lazy — the concrete env
-    lives in `envs/`, which imports `env.py`."""
-    from verifiers.v1.envs.single_agent import SingleAgentEnvConfig
-
-    return SingleAgentEnvConfig()
-
-
-class EnvServerConfig(BaseConfig):
-    """A run's environment plus how it's *served*: the `env` block and the worker-pool
-    sizing. Shared by the `serve` CLI, server-backed eval, and prime-rl's orchestrator, so
-    they all configure the pool the same way (`--pool.type elastic|static`)."""
-
-    # SerializeAsAny: see EnvConfig.taskset — model_dump() must keep the subclass's
-    # agent fields and knobs.
-    env: SerializeAsAny[EnvConfig] = Field(default_factory=_single_agent_env_config)
-    """The environment — the run's `[env]` block: which env, its seed taskset, each
-    agent, its knobs, and the run limits. Narrowed to the selected env's config
-    class by the env id, else the taskset id."""
-    pool: PoolConfig = Field(default_factory=ElasticPoolConfig)
-    """Worker-pool sizing for the env server. `elastic` (default) starts at one worker and
-    scales up on demand; `static` pre-spawns a fixed `num_workers`."""
-    # --- legacy (v0) backwards-compat -----------------------------------------
-    id: ID | None = None
-    """Classic (v0) env id (`name`, `org/name`, or `org/name@version` — installed from the
-    hub on demand), loaded via `verifiers.load_environment` and run through the legacy
-    bridge. Set this *instead of* `env.taskset` to run a v0 environment."""
-    args: dict = Field(default_factory=dict)
-    """Construction kwargs forwarded to `load_environment(id, **args)`."""
-    extra_env_kwargs: dict = Field(default_factory=dict)
-    """Post-load kwargs applied to the v0 env via `env.set_kwargs(**extra_env_kwargs)` (e.g.
-    `max_total_completion_tokens`, `max_seq_len`, `timeout_seconds`) — typically
-    auto-populated by the orchestrator, distinct from the `args` passed at construction."""
-
-    @property
-    def is_legacy(self) -> bool:
-        """A v0/legacy env (run via the bridge): a legacy `id` is set and no v1 taskset."""
-        return self.id is not None and not self.env.taskset.id
-
-    @property
-    def env_id(self) -> str:
-        """The run's identifier: the v1 env's (`EnvConfig.env_id`), else the legacy
-        v0 env id."""
-        return self.env.env_id or self.id or ""
-
-    @model_validator(mode="after")
-    def _refuse_legacy_id_with_taskset(self):
-        """A legacy `id` next to a v1 `env.taskset` would be silently inert
-        (`is_legacy` is False and the v0 env never loads); refuse the mix."""
-        if self.id is not None and self.env.taskset.id:
-            raise ValueError(
-                f"--id {self.id!r} is the legacy (v0) env id and can't combine with "
-                f"the v1 taskset {self.env.taskset.id!r}. Pairing an env with a "
-                f"taskset is --env.id {self.id!r} (TOML: id under [env]); to run the "
-                "v0 env instead, drop the taskset."
-            )
-        return self
-
-    # --- end legacy -----------------------------------------------------------
-
-    @model_validator(mode="before")
-    @classmethod
-    def _resolve_env(cls, data):
-        return resolve_env_field(data, narrowed_env_annotation(cls))

verifiers/v1/configs/cli/eval.py

@@ -3,14 +3,27 @@
 from pathlib import Path
 from uuid import uuid4
 
-from pydantic import AliasChoices, Field, model_validator
+from pydantic import AliasChoices, Field, SerializeAsAny, model_validator
+from pydantic_config import BaseConfig
 
 from verifiers.v1.clients import ClientConfig, EvalClientConfig
-from verifiers.v1.configs.cli.env import EnvServerConfig
+from verifiers.v1.configs.cli.env import narrowed_env_annotation, resolve_env_field
+from verifiers.v1.configs.env import EnvConfig
+from verifiers.v1.configs.legacy import LegacyEnvConfig
+from verifiers.v1.configs.serve import ServingConfig
+from verifiers.v1.envs.single_agent import SingleAgentEnvConfig
 from verifiers.v1.types import SamplingConfig
 
 
-class EvalConfig(EnvServerConfig):
+class EvalConfig(BaseConfig):
+    env: SerializeAsAny[EnvConfig] = SingleAgentEnvConfig()
+    """The environment — which env, its seed taskset, each agent, its knobs. Narrowed to
+    the selected env's config class by the env id, else the taskset id."""
+    serve: ServingConfig = ServingConfig()
+    """How the env is hosted under `--server`: the worker pool, each worker's episode
+    bound. Ignored by an in-process run."""
+    legacy: LegacyEnvConfig = LegacyEnvConfig()
+    """A classic (v0) environment to evaluate through the bridge instead of `[env]`."""
     uuid: str = Field(default_factory=lambda: str(uuid4()), exclude=True)
     """Auto-generated run id — the leaf of the output dir, so runs never overwrite.
     Excluded from the saved config so re-running `@ config.toml` lands in a fresh dir."""
@@ -37,9 +50,12 @@ class EvalConfig(EnvServerConfig):
     shuffle: bool = Field(False, validation_alias=AliasChoices("shuffle", "s"))
     """Shuffle tasks before taking the first `num_tasks`."""
     max_concurrent: int | None = Field(
-        128, validation_alias=AliasChoices("max_concurrent", "c")
+        128, ge=1, validation_alias=AliasChoices("max_concurrent", "c")
     )
-    """Max rollouts in flight at once."""
+    """Episodes in flight at once, `None` for no limit. An episode plays its agents one
+    at a time, so this is the live agent runs too — until `--env.max-concurrent-agents`
+    says otherwise. Under `--server` it seeds each worker's bound, unless
+    `--serve.max-concurrent` pins one."""
     verbose: bool = Field(False, validation_alias=AliasChoices("verbose", "v"))
     """Log at debug level instead of the default info."""
     dry_run: bool = Field(False, exclude=True)
@@ -49,7 +65,7 @@ class EvalConfig(EnvServerConfig):
     """Show a live dashboard instead of per-rollout logs (in-process only; an unset
     `rich` defaults off under `--server`)."""
     server: bool = False
-    """Drive rollouts through the env-server worker pool (sized by `--pool.*`) instead of
+    """Drive rollouts through the env-server worker pool (sized by `[serve]`) instead of
     in-process — the path prime-rl trains through. Incompatible with `--rich`."""
     push: bool = True
     """Upload the finished run to the Prime Intellect platform (the private Evaluations
@@ -80,3 +96,47 @@ class EvalConfig(EnvServerConfig):
                 "`--server`; drop `--rich`."
             )
         return self
+
+    @property
+    def is_legacy(self) -> bool:
+        """Whether this run goes through the v0 bridge: a legacy id and no v1 taskset."""
+        return self.legacy.id is not None and not self.env.taskset.id
+
+    @property
+    def env_id(self) -> str:
+        """The run's identifier: the v1 env's, else the v0 env id."""
+        return self.env.env_id or self.legacy.id or ""
+
+    @property
+    def worker_max_concurrent(self) -> int | None:
+        """A served worker's episode bound: its own pin, else the run's `--max-concurrent`."""
+        return (
+            self.serve.max_concurrent
+            if self.serve.max_concurrent is not None
+            else self.max_concurrent
+        )
+
+    @model_validator(mode="after")
+    def _refuse_mixed_run(self):
+        # A v0 id next to any v1 env identity leaves one of the two going nowhere, and
+        # which one depends on `is_legacy`: a taskset makes it False, so the v0 env never
+        # loads; a bare `--env.id` leaves it True, so the v0 env runs under the v1 name.
+        if self.legacy.id is None or not self.env.env_id:
+            return self
+        if self.env.taskset.id:
+            raise ValueError(
+                f"--legacy.id {self.legacy.id!r} is a classic (v0) env and can't combine "
+                f"with the v1 taskset {self.env.taskset.id!r}. Pairing a reusable env with "
+                f"a taskset is --env.id {self.legacy.id!r} (TOML: id under [env]); to run "
+                "the v0 env instead, drop the taskset."
+            )
+        raise ValueError(
+            f"--legacy.id {self.legacy.id!r} is a classic (v0) env and can't combine with "
+            f"the v1 env --env.id {self.env.id!r}: the v0 env is what would run, stamped "
+            "with the v1 env's name. Keep whichever one you meant to run."
+        )
+
+    @model_validator(mode="before")
+    @classmethod
+    def _resolve_env(cls, data):
+        return resolve_env_field(data, narrowed_env_annotation(cls))

verifiers/v1/configs/cli/serve.py

@@ -1,16 +1,62 @@
 """Environment-server CLI configuration."""
 
-from pydantic import AliasChoices, Field
+from pydantic import AliasChoices, Field, SerializeAsAny, model_validator
+from pydantic_config import BaseConfig
 
-from verifiers.v1.configs.cli.env import EnvServerConfig
+from verifiers.v1.configs.cli.env import narrowed_env_annotation, resolve_env_field
+from verifiers.v1.configs.env import EnvConfig
+from verifiers.v1.configs.legacy import LegacyEnvConfig
+from verifiers.v1.configs.serve import ServingConfig
+from verifiers.v1.envs.single_agent import SingleAgentEnvConfig
 
 
-class ServeConfig(EnvServerConfig):
-    address: str = Field(
-        "tcp://127.0.0.1:5000", validation_alias=AliasChoices("address", "a")
-    )
-    """ZMQ address the ROUTER binds (and clients connect to)."""
+class ServeConfig(BaseConfig):
+    """`uv run serve`: what to serve (`[env]`, or `[legacy]` for a classic v0 env) and
+    how it's hosted (`[serve]`)."""
+
+    env: SerializeAsAny[EnvConfig] = SingleAgentEnvConfig()
+    """The environment — which env, its seed taskset, each agent, its knobs. Narrowed to
+    the selected env's config class by the env id, else the taskset id."""
+    serve: ServingConfig = ServingConfig()
+    """How it's served: the worker pool, the bind address, each worker's episode bound."""
+    legacy: LegacyEnvConfig = LegacyEnvConfig()
+    """A classic (v0) environment to serve through the bridge instead of `[env]`."""
     verbose: bool = Field(False, validation_alias=AliasChoices("verbose", "v"))
     """Log at debug level instead of info."""
     dry_run: bool = False
     """Resolve + validate the config and dump it, then exit."""
+
+    @property
+    def is_legacy(self) -> bool:
+        """Whether this run goes through the v0 bridge: a legacy id and no v1 taskset."""
+        return self.legacy.id is not None and not self.env.taskset.id
+
+    @property
+    def env_id(self) -> str:
+        """The run's identifier: the v1 env's, else the v0 env id."""
+        return self.env.env_id or self.legacy.id or ""
+
+    @model_validator(mode="after")
+    def _refuse_mixed_run(self):
+        # A v0 id next to any v1 env identity leaves one of the two going nowhere, and
+        # which one depends on `is_legacy`: a taskset makes it False, so the v0 env never
+        # loads; a bare `--env.id` leaves it True, so the v0 env runs under the v1 name.
+        if self.legacy.id is None or not self.env.env_id:
+            return self
+        if self.env.taskset.id:
+            raise ValueError(
+                f"--legacy.id {self.legacy.id!r} is a classic (v0) env and can't combine "
+                f"with the v1 taskset {self.env.taskset.id!r}. Pairing a reusable env with "
+                f"a taskset is --env.id {self.legacy.id!r} (TOML: id under [env]); to run "
+                "the v0 env instead, drop the taskset."
+            )
+        raise ValueError(
+            f"--legacy.id {self.legacy.id!r} is a classic (v0) env and can't combine with "
+            f"the v1 env --env.id {self.env.id!r}: the v0 env is what would run, stamped "
+            "with the v1 env's name. Keep whichever one you meant to run."
+        )
+
+    @model_validator(mode="before")
+    @classmethod
+    def _resolve_env(cls, data):
+        return resolve_env_field(data, narrowed_env_annotation(cls))

verifiers/v1/configs/env.py

@@ -3,7 +3,7 @@ each role as an `AgentConfig` field, and the env-level knobs."""
 
 from typing import get_args
 
-from pydantic import SerializeAsAny, model_validator
+from pydantic import Field, SerializeAsAny, model_validator
 from pydantic_config import BaseConfig
 
 from verifiers.v1.configs.agent import AgentConfig
@@ -48,9 +48,16 @@ class EnvConfig(BaseConfig):
     retries: RetryConfig = RetryConfig()
     """Whole-EPISODE retries — the coarse fallback for faults no agent owns; a
     retried episode reruns whole (a half-played sibling context isn't reproducible)."""
-    max_concurrent: int | None = None
-    """Bounds concurrent agent runs on a SERVED env, per worker (None = no limit);
-    the in-process eval CLI gates with its run-level `--max-concurrent` instead."""
+    max_concurrent_agents: int | None = Field(1, ge=1)
+    """How many of ONE episode's agent runs may be active at once (None = no limit).
+    One at a time by default, so the bound above — `--max-concurrent` episodes, a
+    dispatched training episode — is also one live agent run, whatever `run()` fans
+    out to internally. Raise it where per-episode latency matters and the
+    multiplication is wanted: `--env.max-concurrent-agents None` plays an episode's
+    `best-of-n` attempts together, so `-c` episodes carry `-c * n` live runs. Not
+    spelled `max_concurrent`: that key used to bound a served worker's agent runs
+    across episodes, and taking it as this one silently multiplies it by the episodes
+    in flight."""
     interception: InterceptionConfig = ElasticInterceptionPoolConfig()
     """The interception shape: `elastic` (default), `server`, or `static`."""
 

verifiers/v1/configs/legacy.py

@@ -0,0 +1,24 @@
+"""The `[legacy]` block: running a classic (v0) environment through the bridge.
+
+Quarantined in its own block, not mixed into `[env]` — a v0 env is a different
+thing to run, not a variant of a v1 env's config."""
+
+from pydantic import Field
+from pydantic_config import BaseConfig
+
+from verifiers.v1.types import ID
+
+
+class LegacyEnvConfig(BaseConfig):
+    """A classic (v0) `verifiers` environment, loaded via `verifiers.load_environment`
+    and run through the legacy bridge. Set `id` *instead of* a v1 `env.taskset`."""
+
+    id: ID | None = None
+    """v0 env id: `name`, `org/name`, or `org/name@version` — installed from the hub on
+    demand."""
+    args: dict = Field(default_factory=dict)
+    """Construction kwargs forwarded to `load_environment(id, **args)`."""
+    extra_env_kwargs: dict = Field(default_factory=dict)
+    """Post-load kwargs applied via `env.set_kwargs(**extra_env_kwargs)` (e.g.
+    `max_total_completion_tokens`, `max_seq_len`, `timeout_seconds`) — typically
+    auto-populated by a trainer, distinct from the `args` passed at construction."""

verifiers/v1/configs/serve.py

@@ -0,0 +1,63 @@
+"""How an env is served: the worker pool, where it binds, and each worker's bound.
+
+Serving is its own axis. `[env]` says what runs; this says how it's hosted, so an
+eval, a `serve` process, and a trainer configure it identically instead of each
+flattening pool knobs onto its own config."""
+
+from typing import Annotated, Literal
+
+from pydantic import Field
+from pydantic_config import BaseConfig
+
+
+class StaticPoolConfig(BaseConfig):
+    """Fixed env-server pool: pre-spawn `num_workers` workers up front."""
+
+    type: Literal["static"] = "static"
+    num_workers: int = Field(4, ge=1)
+    """Worker processes to pre-spawn (1 = a single in-process server, no pool)."""
+
+
+class ElasticPoolConfig(BaseConfig):
+    """Elastic env-server pool: start at one worker and scale up on demand."""
+
+    type: Literal["elastic"] = "elastic"
+    max_workers: int | None = None
+    """Upper bound on workers (None = unbounded)."""
+    multiplex: int = Field(128, ge=1)
+    """Episodes per worker for the scale-up trigger: add a worker once in-flight episodes
+    reach 90% of `workers * multiplex`."""
+
+
+# Discriminated on `type` so the CLI selects with `--serve.pool.type static|elastic`.
+PoolConfig = Annotated[
+    StaticPoolConfig | ElasticPoolConfig, Field(discriminator="type")
+]
+
+
+class ServingConfig(BaseConfig):
+    """The `[serve]` block: the worker pool, the ZMQ address, and each worker's
+    episode bound. Read by whoever hosts the env — the `serve` CLI, a server-backed
+    eval, a trainer's orchestrator."""
+
+    pool: PoolConfig = Field(default_factory=ElasticPoolConfig)
+    """Worker-pool sizing. `elastic` (default) starts at one worker and scales up on
+    demand; `static` pre-spawns a fixed `num_workers`."""
+    address: str = "tcp://127.0.0.1:5000"
+    """ZMQ address the ROUTER binds (and clients connect to)."""
+    max_concurrent: int | None = Field(None, ge=1)
+    """Episodes in flight per worker (None = take the run's own bound, e.g. an eval's
+    `--max-concurrent`). Pin it to hold a worker below what the run asks for; how many
+    agent runs one episode carries is the env's own
+    (`--env.max-concurrent-agents`, one at a time by default)."""
+
+
+def pool_serve_kwargs(pool: StaticPoolConfig | ElasticPoolConfig) -> dict:
+    """Unpack a pool config into `serve_env` kwargs (`max_workers` / `multiplex` / `elastic`)."""
+    if isinstance(pool, ElasticPoolConfig):
+        return {
+            "max_workers": pool.max_workers,
+            "multiplex": pool.multiplex,
+            "elastic": True,
+        }
+    return {"max_workers": pool.num_workers, "elastic": False}

verifiers/v1/env.py

@@ -154,7 +154,10 @@ class Env(ABC, Generic[ConfigT]):
         """One episode: how the agents interact on `task`, returning nothing —
         every finished run joins the episode automatically, stamped with its seat's
         standing. An agent-run failure is data on its trace (this hook decides what
-        it means); an exception raised here is the episode itself failing."""
+        it means); an exception raised here is the episode itself failing.
+        Independent agents are written as such (`asyncio.gather`); how many of them
+        actually run at once is the run's bound, not this hook's
+        (`--env.max-concurrent-agents`, one at a time by default)."""
 
     async def finalize(self, task: Task, episode: Episode) -> None:
         """Cross-agent judgement — THE programmable judgement surface: plain
@@ -188,13 +191,16 @@ class Env(ABC, Generic[ConfigT]):
     def _episode_agents(
         self,
         ctx: ModelContext,
-        gate: "asyncio.Semaphore | None",
         completed: list[Trace],
         on_trace: Callable[[Trace], None] | None,
         on_discard: Callable[[Trace], None] | None,
     ) -> Agents:
         """One episode's `Agents` — fresh value objects riding the live serving
-        resources (nothing shared across concurrent episodes); `setup()` sees them first."""
+        resources (nothing shared across concurrent episodes), sharing one semaphore
+        so the episode plays `--env.max-concurrent-agents` of them at a time;
+        `setup()` sees them first."""
+        limit = self.config.max_concurrent_agents
+        gate = asyncio.Semaphore(limit) if limit else None
 
         def make(name: str, spec: AgentConfig) -> Agent:
             # Unpinned fields fall back to the run's ctx / the taskset's harness.
@@ -242,17 +248,17 @@ class Env(ABC, Generic[ConfigT]):
         *,
         on_trace: Callable[[Trace], None] | None = None,
         on_discard: Callable[[Trace], None] | None = None,
-        gate: asyncio.Semaphore | None = None,
     ) -> Episode:
         """One episode of `task`, minted as the wire atom: `setup()` then `run()`
-        over fresh agents, then `finalize()`; `gate` bounds
-        the agent runs, so internal fan-out counts against `--max-concurrent` too.
+        over fresh agents, then `finalize()`. Its agents run one at a time
+        (`--env.max-concurrent-agents`), so one live episode is one live agent run
+        however `run()` fans out.
         Traces join the episode as runs complete — a hook raising mid-way yields the
         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)
-        agents = self._episode_agents(ctx, gate, episode.traces, on_trace, on_discard)
+        agents = self._episode_agents(ctx, episode.traces, on_trace, on_discard)
         try:
             async with asyncio.timeout(self.config.timeout.episode):
                 async with boundary(EnvError, f"{type(self).__name__}.setup()"):
@@ -306,8 +312,10 @@ class Env(ABC, Generic[ConfigT]):
         on_complete: Callable[[Episode], Awaitable[None]] | None = None,
     ) -> Episode:
         """Run one planned episode to completion, with whole-episode
-        retries per `--env.retries`; `semaphore` gates the agent RUNS, not the
-        episode; `on_complete` (the runners' persistence hook) fires when final."""
+        retries per `--env.retries`; `semaphore` bounds concurrent EPISODES — one
+        permit for the attempt in flight, held across the whole of it (its agents,
+        their boxes, `finalize()`) and released before a retry's backoff and before
+        `on_complete` (the runners' persistence hook, which fires when final)."""
 
         async def attempt() -> Episode:
             slot.traces = []  # a retry shows the fresh attempt's traces
@@ -318,13 +326,13 @@ class Env(ABC, Generic[ConfigT]):
                 with contextlib.suppress(ValueError):
                     live.remove(trace)
 
-            return await self.run_episode(
-                slot.task,
-                ctx,
-                on_trace=live.append,
-                on_discard=discard,
-                gate=semaphore,
-            )
+            async with semaphore or contextlib.nullcontext():
+                return await self.run_episode(
+                    slot.task,
+                    ctx,
+                    on_trace=live.append,
+                    on_discard=discard,
+                )
 
         episode = await run_episode_with_retry(attempt, self.config.retries)
         slot.traces = list(episode.traces)

verifiers/v1/gepa/config.py

@@ -4,9 +4,9 @@ GEPA optimizes one taskset's `Task.system_prompt` by alternating rollouts (`eval
 teacher LM reflecting on the reflective dataset (`make_reflective_dataset`) — see
 `verifiers.v1.gepa.adapter.GEPAAdapter`. Like `EvalConfig`, it owns an `env` field (the
 environment: its taskset, seats, limits) and adds the optimization loop's own knobs (model,
-reflection model, train/val split, budget). There is no worker pool here (`EnvServerConfig`
-is not a base) — GEPA always runs in-process, since its adapter protocol is itself
-synchronous (see `GEPAAdapter`)."""
+reflection model, train/val split, budget). There is no `[serve]` block here — GEPA
+always runs in-process, since its adapter protocol is itself synchronous (see
+`GEPAAdapter`)."""
 
 from pathlib import Path
 from uuid import uuid4

verifiers/v1/legacy.py

@@ -495,7 +495,7 @@ def _legacy_output_dir(config) -> Path:
 
     if config.output_dir is not None:
         return config.output_dir
-    name = f"{env_name(config.id)}--{config.model.replace('/', '--')}--legacy"
+    name = f"{env_name(config.legacy.id)}--{config.model.replace('/', '--')}--legacy"
     return Path("outputs") / name / config.uuid
 
 
@@ -510,15 +510,21 @@ async def run_legacy_eval(config) -> list[Episode]:
 
     # Install from the env hub on demand for an `org/name[@version]` id (a local id is
     # already importable), then load by module name.
-    env = load_environment(ensure_installed(config.id), **(config.args or {}))
-    if config.extra_env_kwargs:  # post-load knobs (max_total_completion_tokens, …)
-        env.set_kwargs(**config.extra_env_kwargs)
+    env = load_environment(
+        ensure_installed(config.legacy.id), **(config.legacy.args or {})
+    )
+    if (
+        config.legacy.extra_env_kwargs
+    ):  # post-load knobs (max_total_completion_tokens, …)
+        env.set_kwargs(**config.legacy.extra_env_kwargs)
     dataset = env.get_eval_dataset()  # the eval split (falls back to train when unset)
     idxs = sample(list(range(len(dataset))), config.shuffle, config.num_tasks)
 
     client = _eval_client(config.client, config.model)
     sampling_args = config.sampling.model_dump(exclude_none=True)
-    taskset_id = env_name(config.id)  # the same identity the served bridge stamps
+    taskset_id = env_name(
+        config.legacy.id
+    )  # the same identity the served bridge stamps
     out_dir = _legacy_output_dir(config)
     save_config(config, out_dir)
     logger.info("results: %s", out_dir)
@@ -527,7 +533,7 @@ async def run_legacy_eval(config) -> list[Episode]:
         len(idxs),
         config.num_rollouts,
         config.model,
-        config.id,
+        config.legacy.id,
     )
 
     sem = asyncio.Semaphore(config.max_concurrent) if config.max_concurrent else None

verifiers/v1/push.py

@@ -186,7 +186,7 @@ def push_traces(
         return finish(error="no PRIME_API_KEY (run `prime login`)")
 
     traces = [trace for episode in episodes for trace in episode.traces]
-    env_name = (config.env.taskset.id) or config.id
+    env_name = (config.env.taskset.id) or config.legacy.id
     metrics = _run_metrics(episodes, traces)
     samples = _build_samples(episodes)
     num_examples = len({t.task.data.idx for t in traces})

verifiers/v1/serve/pool.py

@@ -312,9 +312,10 @@ def serve_env(
             if (
                 "config" in server_kwargs
             ):  # dict-ify for the workers (config_data is picklable)
-                server_kwargs = {
-                    "config_data": env_config_data(server_kwargs["config"])
-                }
+                server_kwargs = {**server_kwargs}
+                server_kwargs["config_data"] = env_config_data(
+                    server_kwargs.pop("config")
+                )
             pool = EnvServerPool(
                 server_kwargs,
                 max_workers,
@@ -335,9 +336,10 @@ def serve_env(
             ):  # rebuild the env config for an in-process server
                 from verifiers.v1.loaders import resolve_env_config
 
-                server_kwargs = {
-                    "config": resolve_env_config(server_kwargs["config_data"])
-                }
+                server_kwargs = {**server_kwargs}
+                server_kwargs["config"] = resolve_env_config(
+                    server_kwargs.pop("config_data")
+                )
             cls = LegacyEnvServer if legacy else EnvServer
             cls.run_server(
                 address=address, address_queue=address_queue, **server_kwargs

verifiers/v1/serve/server.py

@@ -30,7 +30,10 @@ logger = logging.getLogger(__name__)
 
 class EnvServer:
     def __init__(
-        self, config: EnvConfig, address: str = "tcp://127.0.0.1:5000"
+        self,
+        config: EnvConfig,
+        address: str = "tcp://127.0.0.1:5000",
+        max_concurrent: int | None = None,
     ) -> None:
         self.address = address
         self.taskset_id = config.taskset.id
@@ -52,9 +55,8 @@ class EnvServer:
         # v1 envs never group-score (siblings score inside the env's own rollout);
         # only the legacy (v0) bridge sets this.
         self.requires_group_scoring = False
-        self._gate = (
-            asyncio.Semaphore(config.max_concurrent) if config.max_concurrent else None
-        )
+        # This worker's episode bound (`--max-concurrent`), spanning requests.
+        self._gate = asyncio.Semaphore(max_concurrent) if max_concurrent else None
         self._clients: dict[
             tuple[str, str], Client
         ] = {}  # (client_config, model) -> Client
@@ -122,8 +124,8 @@ class EnvServer:
     async def _run(self, req: RunRequest) -> RunResponse:
         ctx = self._context(req.client, req.model, req.sampling)
         (slot,) = self.env.slots(self._build_task(req.task_data))
-        # The gate spans requests: `--env.max-concurrent` bounds this worker's
-        # agent runs the same way the in-process eval's semaphore does.
+        # The gate spans requests: `--max-concurrent` bounds this worker's episodes
+        # in flight the same way the in-process eval's semaphore does.
         episode = await self.env.run_slot(slot, ctx, self._gate)
         # Trust the env-minted episode; serialize it once before client-side re-typing.
         return RunResponse.model_construct(episode=episode)

{verifiers-0.2.2.dev42.dist-info → verifiers-0.2.2.dev44.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: verifiers
-Version: 0.2.2.dev42
+Version: 0.2.2.dev44
 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
@@ -39,7 +39,7 @@ Requires-Dist: prime-sandboxes>=0.2.33
 Requires-Dist: prime-tunnel>=0.1.8
 Requires-Dist: pydantic>=2.12.3
 Requires-Dist: pyzmq>=27.1.0
-Requires-Dist: renderers>=0.1.8
+Requires-Dist: renderers>=0.1.9.dev9
 Requires-Dist: requests
 Requires-Dist: rich>=11.0.0
 Requires-Dist: setproctitle>=1.3.0

{verifiers-0.2.2.dev42.dist-info → verifiers-0.2.2.dev44.dist-info}/RECORD

@@ -167,18 +167,18 @@ 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=QC3A5qz54RGO9WHAUg35zVt-Gde7JLf8ROCrwSLLy9U,7119
-verifiers/v1/agent.py,sha256=MAwqTuUcdBPlPwQ-DTYCwZI-duQH-h5PAS5lKxPpfeI,31875
+verifiers/v1/__init__.py,sha256=xHKE-HZA8bN0JJovf4KbBI2mxBtZJ4hPNnzac4FtWwM,7332
+verifiers/v1/agent.py,sha256=2MJBztogGCwDMt0DVZuuItADgZpTk3Xaf_x_cQswdds,31956
 verifiers/v1/decorators.py,sha256=9CcCwgZlRjVGPqT5G1CFJUHP4OIMuBGkUJZkcI6dnbk,3865
-verifiers/v1/env.py,sha256=QFwhD1NKbEUWGf0l6G2ttK4JLbhUt2MUCDciWaaJ_1s,17834
+verifiers/v1/env.py,sha256=Omfwspenzs7A_K-0oDVPH1lHS8YkzihmJEZ2DjK4Kqs,18445
 verifiers/v1/episode.py,sha256=KWyM9ovTphEIo2260BYu2HvtnOOTxjLRDPrF_jTCiuA,2497
 verifiers/v1/errors.py,sha256=Pj5Om8x1fP3TDPQQn6nUCoSPoZRsy2JeBz8pXhpPrDY,6883
 verifiers/v1/graph.py,sha256=-j8MNdIv1r5ifajv5ggnGPsfBNB74IO3WKLcrpYh9hg,29102
 verifiers/v1/harness.py,sha256=cDiDuhp29aqL4CxiqSZz-IT0QlOcVlye_vTTHZblWo8,10948
 verifiers/v1/judge.py,sha256=VnTi9iSfCJMCccYWc1qCTcT7iD3AcomS2cXfHwh1HVw,9423
-verifiers/v1/legacy.py,sha256=kGfx4CEmk17VEqwX6JfUBbjQRMqJ0tL4kkA2kqGypN8,22305
+verifiers/v1/legacy.py,sha256=aPpHsiNyW3Ail3U8Nfx9XM6tS__Py_haEluiZWVQ50k,22398
 verifiers/v1/loaders.py,sha256=TnNKY2msVo3p7m-5wjw376PYH-zTu3TLixXRst0VOiM,9985
-verifiers/v1/push.py,sha256=LstxyShYGWl-tXRyuSoA_YIXytdydPVjhTJET_o3ZVI,11334
+verifiers/v1/push.py,sha256=uq4ZQBYNPQhNsNORNmlWEwTL186E4deGXGqG6fZBQgM,11341
 verifiers/v1/retries.py,sha256=GAUQB2k-SJGnKjLpI1Y_XOmhSBeqIquljkXQHXYfg88,5380
 verifiers/v1/rollout.py,sha256=eU01fZRf87lQ5LQUVIDN38SlcUE0svXxfyS0gryNboE,20503
 verifiers/v1/scoring.py,sha256=-R5Cog14r_tJ6Q_oOfGr5VPAm2CCUhofYZB6B9lm4wM,5787
@@ -197,17 +197,17 @@ verifiers/v1/cli/init.py,sha256=dVpX1YMz7DFmHgskAsPjP-HmVTGoZfC0ZUyE-T4I6l0,8322
 verifiers/v1/cli/output.py,sha256=pMS5Z0EBgyAVShNCAk9jVURNeLOaTfeRWpt0J8hHjq8,5890
 verifiers/v1/cli/replay.py,sha256=T4sg-MpvT9niymEJl0Y2TijgTy-tVQqjT1lQ3nwuOg8,10314
 verifiers/v1/cli/resolve.py,sha256=1sV4z04v_HEs86Oi8ODJqfujXjrbShbu3u2kDpgpj94,4079
-verifiers/v1/cli/serve.py,sha256=CIO6stXkIe-CozLpJMQZDRNAYyvVNyu3TrDtpiG3r-4,2667
+verifiers/v1/cli/serve.py,sha256=_mdJaHVVe4pXzcpAot0ugcmiN3ra2gS4GrGmLghnX5M,2866
 verifiers/v1/cli/validate.py,sha256=PMWRSZROiTh2KFzkA3Ez5-z09krVk2ZUTkFNMUqk2-4,9671
 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=HcdZKSkHVcA-lLMDgIZyI5coWOvp1l9w-id7Om38V7c,34357
+verifiers/v1/cli/dashboard/eval.py,sha256=lPrP7Ikmz3r7v3ury2yAMLgYeweVGFdg0ZKSQ6lwwKU,34355
 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
-verifiers/v1/cli/eval/main.py,sha256=bOAClP3qn_0JnyWu0Or5nLcl-cX-Y9AqKb2NrBFbA64,5481
+verifiers/v1/cli/eval/main.py,sha256=zvbLy_ryn3S1fWoTmWL4QEReVO1Q_hIrgyK6Fp0q_ZM,5501
 verifiers/v1/cli/eval/resume.py,sha256=QwXuLPs2lN-aMZk1CyaT12egRPzeI6vfY39DAd0nYLU,7171
-verifiers/v1/cli/eval/runner.py,sha256=dKzeCTMRwUWwOLH15s3pCqZgRZmI03PYuRbzvw0IKDU,11212
+verifiers/v1/cli/eval/runner.py,sha256=PwcIaVLGBJON9nC2u3z6aTGALmoa0vKAYrg0IYM-8Dw,11493
 verifiers/v1/clients/__init__.py,sha256=bHGS5jfrAZ-VBUeXpasXkkKdHkFgjOSN9KbOJXrnFtU,511
 verifiers/v1/clients/client.py,sha256=9gZScQM6CVQq9RZ_3slVBEsik6tr56uOFSVNvQfMdFQ,3288
 verifiers/v1/clients/config.py,sha256=QMR0PkpFLcLi_Zw6bVimigNjNiWeJ-4YvJ_JsSS9yGw,5228
@@ -215,19 +215,21 @@ verifiers/v1/clients/eval.py,sha256=QMpohNnQjDuo56BhOgHnAfAlcnQAxFpEFCySoIuexNg,
 verifiers/v1/clients/train.py,sha256=6bw4TV_UskdjvDAxvHrgJWBqAq9r1DxzJGusGi7UoRM,13022
 verifiers/v1/configs/__init__.py,sha256=X7u6X7B3ieD1HZl79Tv1kg-yPHbT0QLvAebaGqxVtvA,317
 verifiers/v1/configs/agent.py,sha256=N2Lm0iZXFxfsSIiXUQ7f3RDZcoin3M7pJj6HVdCE5eo,3537
-verifiers/v1/configs/env.py,sha256=2mEU1n2xG-v5PNdB2EJioAYP6Witnlny9kYi0jwKFQk,7286
+verifiers/v1/configs/env.py,sha256=4aUap3BJX3WCA2_fZ-jGPxF3khiVpORqmz_3eBT4j9w,7824
 verifiers/v1/configs/harness.py,sha256=CG8hGbHl3rr6yawH3YYMAFl01M7Piiwf4w5oiw2Vagg,1564
 verifiers/v1/configs/judge.py,sha256=ZJlmWogHY8oDjvWvtNuVKvkzuheWalIjl1njJ4dE0Mk,2511
+verifiers/v1/configs/legacy.py,sha256=YOJM6L5u6-jYpZ1CLpPInufKdmz1lEsMNKIRdT2JaaY,1080
 verifiers/v1/configs/retries.py,sha256=-nPlgmz7J_NZ4GOYG6oCc3thXo4La2SufBmvQGvvPGo,821
+verifiers/v1/configs/serve.py,sha256=cHHnFGQtqEwvaovdeoVMpCebTHgPXKUuIivN5IhxZR0,2596
 verifiers/v1/configs/task.py,sha256=1ozZjfpahin7I_TqzC7f3xr7CHSthAdydegFPXW4d9k,1101
 verifiers/v1/configs/taskset.py,sha256=IdZwsarn0_WvYdR_Kr4QYYdqbaoGYkbYyO5VA-RPYPc,657
 verifiers/v1/configs/cli/__init__.py,sha256=3wBAONw5XkBPqbMjpHk5XBHlBVybR8JQ2JCPWijYBMU,444
 verifiers/v1/configs/cli/debug.py,sha256=3lkKqmQFLJBcUZECChBHCrod5pbCKSmT47EhjILrxjI,2843
-verifiers/v1/configs/cli/env.py,sha256=Rw7KtAR-mKowlnn8Vc-dGpOWfknUyS6SyIu4jpGt1sk,7359
-verifiers/v1/configs/cli/eval.py,sha256=A5k7Iigd-mlv_2TMF-b3DNbneMhflO0fSWSOI9oRJtA,3812
+verifiers/v1/configs/cli/env.py,sha256=XgjRXYpPjga0ZYIHEESY7VuVvtE6pWfAzf6JBLeuTIc,2695
+verifiers/v1/configs/cli/eval.py,sha256=YWYMvPOIAG51e0JdmyA-U_P7eInMPZ_8DTFim6aWn6Y,6869
 verifiers/v1/configs/cli/init.py,sha256=tMaTDF_lU1Af3JmQpksk2mwe8CAfpnHsquXhwepZhYo,1019
 verifiers/v1/configs/cli/replay.py,sha256=57R-OZnVXPyrRVrWq2UeBBhnBgTdjGs1DJ_PWjNU3AY,2907
-verifiers/v1/configs/cli/serve.py,sha256=p5xLSVPBTX5DfjqWX9bsFbvFZqmOXYdmMOiII6Nntuk,573
+verifiers/v1/configs/cli/serve.py,sha256=1rAt0QOL-XT3DMmRUIA40t1E3YuoD1vOADfsiTwFBf0,2981
 verifiers/v1/configs/cli/validate.py,sha256=xaYUjQ0MEAAbA_jp55zAtYxlTettZivUC0Tu1H1WZ50,2292
 verifiers/v1/dialects/__init__.py,sha256=p72C7VYrFQzVgTcfmzpHGSwXlvThfc4pvjBxsqw7kHE,786
 verifiers/v1/dialects/anthropic.py,sha256=nj9J7OOhexmPHa-sWiNP2xlI9_bGhvwM5VWzdh19pBc,13526
@@ -245,7 +247,7 @@ verifiers/v1/envs/user_sim/__init__.py,sha256=nnT695HdqjAEouYL5wtVu6MhIp2wf5yuK-
 verifiers/v1/envs/user_sim/env.py,sha256=u376-UJEVdzgcit7FXjz5KEwlPxSU3qqoIrxs6foi2w,4567
 verifiers/v1/gepa/__init__.py,sha256=6nmdRE0-34AKioPHBjTxUg5Jo_2z7tMX-OU3zMNpAJI,197
 verifiers/v1/gepa/adapter.py,sha256=Wo3adNf1I3eT4L_03vxWrrg6HvZBz5KDQonCsGdhLgg,6185
-verifiers/v1/gepa/config.py,sha256=MVaJfPMehoPq5kF1vsm3lEJrxTiryesxHrQDcxE6TAE,4656
+verifiers/v1/gepa/config.py,sha256=gFn8Re4GoeHJs2PZ-iw4jCEZ72AiM1lNgwaA0uvJlYw,4626
 verifiers/v1/gepa/dataset.py,sha256=N2QYqUljHVuAdCbUuydEIlarvAWa6LFdGKu9qsOvjro,2186
 verifiers/v1/gepa/reflection.py,sha256=ptHhx0lcDLcWhWhXuslh9T8gPVNpnX5XLPtXoneW1yA,1054
 verifiers/v1/gepa/runner.py,sha256=o7Am2Ram-Ejbr_tVpN70zb0uQ5a1NIpXvlMhwWL22Xs,5406
@@ -301,8 +303,8 @@ verifiers/v1/runtimes/docker/__init__.py,sha256=eC5hjfyPwvwEKaeZUeP9EN8tJkrl0HUx
 verifiers/v1/runtimes/docker/egress.py,sha256=37UXgNX9gnoLxjMg4KZaJIGoApCAM6MK22eJGNoMi38,14514
 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=cqSGUJvSavV4o73-PisacP5EyEXnQH_DCL9oFuBL5YU,14724
-verifiers/v1/serve/server.py,sha256=gTrSZYSG2DH-KpAhLMN2L1oaMC6oJrqtguNrDfgHQFU,9600
+verifiers/v1/serve/pool.py,sha256=e9Nc3nQKEyV9YqyKHl_RuqQ84zWVa8z2J1rc3rfCadM,14828
+verifiers/v1/serve/server.py,sha256=VBOD3Gzq4p0ZD_8xgtG039i3JaefhOH0MmR6cxG56iY,9705
 verifiers/v1/serve/types.py,sha256=AHFbt8C-Rzlee34RDPLQ3lPiYDLkUm5eFMnRQINiO6s,3016
 verifiers/v1/tasksets/__init__.py,sha256=b62O4WDNbGfJH_4NjYmznn5otWovdfvUgJZyoIZyLh8,596
 verifiers/v1/tasksets/harbor/__init__.py,sha256=wwVGA8N7E2Q2qA5WGHuLRrn4DgG5oaRHrCS2RW3NXVY,195
@@ -327,8 +329,8 @@ verifiers/v1/utils/logging.py,sha256=OcMHA6NsYux3oIzjPuI95rDWmFBHNcHDjZeNIhXTX-Y
 verifiers/v1/utils/memory.py,sha256=ZkIvGk6uITAH5sKon65LifKPbvZr8mJ__PVc23FZpOQ,1835
 verifiers/v1/utils/sampling.py,sha256=JczGzBn6s3wsIrSY2Hy3hE8m6NreNgsNzhSjDikQqX0,1037
 verifiers/v1/utils/version.py,sha256=-obEo_-l9-D8FLef4hYxncOe-uJpxrM1g2Hig_37Sgs,1607
-verifiers-0.2.2.dev42.dist-info/METADATA,sha256=Sfv8yHjesqeUSatEPoWH_rvAosXXPvZ2xczF2O7_mzI,4540
-verifiers-0.2.2.dev42.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-verifiers-0.2.2.dev42.dist-info/entry_points.txt,sha256=dF82JUYEFslR1AOW8LZfuBWeZeQoyX4wCRrduklg8-I,551
-verifiers-0.2.2.dev42.dist-info/licenses/LICENSE,sha256=v0RrUsdV3IDoZhrRce297IXS3xMHNJ-_LdLpFAUWb9k,1072
-verifiers-0.2.2.dev42.dist-info/RECORD,,
+verifiers-0.2.2.dev44.dist-info/METADATA,sha256=xAsUe3hwzJqF-nbNTppTvycNvcRTi_cnhIq8oFj9adQ,4545
+verifiers-0.2.2.dev44.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+verifiers-0.2.2.dev44.dist-info/entry_points.txt,sha256=dF82JUYEFslR1AOW8LZfuBWeZeQoyX4wCRrduklg8-I,551
+verifiers-0.2.2.dev44.dist-info/licenses/LICENSE,sha256=v0RrUsdV3IDoZhrRce297IXS3xMHNJ-_LdLpFAUWb9k,1072
+verifiers-0.2.2.dev44.dist-info/RECORD,,