verifiers 0.3.1.dev10__tar.gz → 0.3.1.dev12__tar.gz

{verifiers-0.3.1.dev10 → verifiers-0.3.1.dev12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: verifiers
-Version: 0.3.1.dev10
+Version: 0.3.1.dev12
 Summary: Verifiers: Environments for LLM Reinforcement Learning
 Project-URL: Homepage, https://github.com/primeintellect-ai/verifiers
 Project-URL: Documentation, https://github.com/primeintellect-ai/verifiers

{verifiers-0.3.1.dev10 → verifiers-0.3.1.dev12}/pyproject.toml

@@ -76,10 +76,10 @@ dev = [
 # from this repo. The built-in tasksets/harnesses ship inside verifiers (verifiers/v1/...).
 examples = [
     "compact",
-    "gsm8k-v1", "glossary-v1", "deepwiki-v1", "wiki-search-v1", "code-golf-v1",
-    "proposer-solver-v1", "reverse-text-v1", "color-codeword-v1",
-    "wordle-v1", "openenv-wordle-v1", "alphabet-sort-v1", "scratchpad-v1",
-    "kuhn-poker-v1",
+    "gsm8k", "glossary", "deepwiki", "wiki-search", "code-golf",
+    "proposer-solver", "reverse-text", "color-codeword",
+    "wordle", "openenv-wordle", "alphabet-sort", "scratchpad",
+    "kuhn-poker",
 ]
 
 [project.optional-dependencies]
@@ -151,19 +151,19 @@ default = true
 
 [tool.uv.sources]
 compact = { path = "environments/compact", editable = true }
-glossary-v1 = { path = "environments/glossary_v1", editable = true }
-deepwiki-v1 = { path = "environments/deepwiki_v1", editable = true }
-wiki-search-v1 = { path = "environments/wiki_search_v1", editable = true }
-gsm8k-v1 = { path = "environments/gsm8k_v1", editable = true }
-code-golf-v1 = { path = "environments/code_golf_v1", editable = true }
-proposer-solver-v1 = { path = "environments/proposer_solver_v1", editable = true }
-reverse-text-v1 = { path = "environments/reverse_text_v1", editable = true }
-wordle-v1 = { path = "environments/wordle_v1", editable = true }
-openenv-wordle-v1 = { path = "environments/openenv_wordle_v1", editable = true }
-color-codeword-v1 = { path = "environments/color_codeword_v1", editable = true }
-alphabet-sort-v1 = { path = "environments/alphabet_sort_v1", editable = true }
-scratchpad-v1 = { path = "environments/scratchpad_v1", editable = true }
-kuhn-poker-v1 = { path = "environments/kuhn_poker_v1", editable = true }
+glossary = { path = "environments/glossary", editable = true }
+deepwiki = { path = "environments/deepwiki", editable = true }
+wiki-search = { path = "environments/wiki_search", editable = true }
+gsm8k = { path = "environments/gsm8k", editable = true }
+code-golf = { path = "environments/code_golf", editable = true }
+proposer-solver = { path = "environments/proposer_solver", editable = true }
+reverse-text = { path = "environments/reverse_text", editable = true }
+wordle = { path = "environments/wordle", editable = true }
+openenv-wordle = { path = "environments/openenv_wordle", editable = true }
+color-codeword = { path = "environments/color_codeword", editable = true }
+alphabet-sort = { path = "environments/alphabet_sort", editable = true }
+scratchpad = { path = "environments/scratchpad", editable = true }
+kuhn-poker = { path = "environments/kuhn_poker", editable = true }
 
 [tool.uv.exclude-newer-package]
 # Bounded cutoffs for the explicitly requested tool upgrades.
@@ -238,6 +238,12 @@ Documentation = "https://github.com/primeintellect-ai/verifiers"
 Repository = "https://github.com/primeintellect-ai/verifiers.git"
 Issues = "https://github.com/primeintellect-ai/verifiers/issues"
 
+[tool.ruff.lint.isort]
+# The legacy tree answers at both verifiers.* and verifiers.legacy.* (the
+# package-root alias); path probing would classify the moved submodules as
+# third-party, so pin the whole namespace first-party.
+known-first-party = ["verifiers"]
+
 [tool.pytest.ini_options]
 minversion = "7.0"
 testpaths = ["tests"]
@@ -300,7 +306,7 @@ redundant-cast = "ignore"
 exclude = ["environments", "verifiers/v1"]
 
 [[tool.ty.overrides]]
-include = ["verifiers/envs/experimental/composable/tasksets/**"]
+include = ["verifiers/legacy/envs/experimental/composable/tasksets/**"]
 
 [tool.ty.overrides.rules]
 unresolved-import = "ignore"

{verifiers-0.3.1.dev10 → verifiers-0.3.1.dev12}/tests/v1/conftest.py

@@ -5,8 +5,7 @@ settings that still exercise the path, then assert on the resulting `Trace`(s)
 not unit tests of individual components. They need a model API key (`PRIME_API_KEY`);
 without one the `e2e`-marked tests skip (config parsing still runs).
 
-`run_v1` / `run_v0` mirror the eval CLI's two paths (`run_eval` for a v1 taskset,
-`run_legacy_eval` for a v0 env). Placement coverage (harness x harness runtime x tool
+`run_v1` mirrors the eval CLI's server path (`run_eval`). Placement coverage (harness x harness runtime x tool
 server runtime) is PAIRWISE, not a full cross product: each test carries a curated list of
 combinations (in test_e2e.py) that hits every axis value and the cross-boundary pairs with
 distinct networking. The full cross bought flake exposure and CI minutes, not coverage — add
@@ -46,9 +45,8 @@ from verifiers.v1.utils.loaders import load_environment
 
 CI_MODEL = "openai/gpt-5.6-luna"
 
-# Fixture tasksets/envs (echo-v1, echo-agentic-v1, echo-v0, echo-multi-v0) live in
-# tests/v1/fixtures, added to the path via `pythonpath` in pyproject so the v1 loader and the
-# v0 legacy bridge both resolve them by id (no install).
+# Fixture tasksets (echo-v1, echo-agentic-v1) live in tests/v1/fixtures, added to the
+# path via `pythonpath` in pyproject so the loader resolves them by id (no install).
 
 # The placement fixtures translate one parametrized value each; the combinations live on
 # the tests (`indirect=True`), so coverage is a visible, curated list — never an implicit
@@ -84,7 +82,7 @@ def pytest_configure(config) -> None:
     """Self-launching tool servers run `python -m <module>` in a fresh subprocess, which
     inherits `PYTHONPATH` but not pytest's in-process `pythonpath`. Put the fixture dir on
     `PYTHONPATH` so a fixture server module (e.g. `tool_response_image_v1`)
-    resolves there too — an installed example package (e.g. `glossary_v1`) already would."""
+    resolves there too — an installed example package (e.g. `glossary`) already would."""
     fixtures = str(Path(__file__).parent / "fixtures")
     existing = os.environ.get("PYTHONPATH", "")
     if fixtures not in existing.split(os.pathsep):
@@ -231,31 +229,3 @@ async def live_ctx():
         client=EvalClientConfig(),
         sampling=SamplingConfig(max_tokens=2048),
     )
-
-
-@pytest.fixture
-def run_v0():
-    """Run a legacy v0 env through the v1 bridge (the eval CLI's `--legacy.id` path)."""
-    from verifiers.v1.legacy import run_legacy_eval
-
-    async def _run(
-        env_id: str,
-        *,
-        output_dir: Path,
-        n: int = 1,
-        max_tokens: int = 2048,
-        args: dict | None = None,
-    ) -> list[Trace]:
-        config = EvalConfig(
-            legacy={"id": env_id, "args": args or {}},
-            model=CI_MODEL,
-            num_tasks=1,
-            num_rollouts=n,
-            sampling={"max_tokens": max_tokens},
-            rich=False,
-            output_dir=output_dir,
-        )
-        records = await run_legacy_eval(config)
-        return [t for r in records for t in r.traces]
-
-    return _run

{verifiers-0.3.1.dev10 → verifiers-0.3.1.dev12}/tests/v1/test_color_codeword_tasks.py

@@ -1,4 +1,4 @@
-from color_codeword_v1 import taskset
+from color_codeword import taskset
 
 
 def test_color_images_are_rendered_once(monkeypatch) -> None:

{verifiers-0.3.1.dev10 → verifiers-0.3.1.dev12}/tests/v1/test_configs.py

@@ -23,5 +23,4 @@ CONFIGS = sorted(
 @pytest.mark.parametrize("path", CONFIGS, ids=lambda p: p.name)
 def test_eval_config_parses(path: Path) -> None:
     config = EvalConfig.model_validate(tomllib.load(path.open("rb")))
-    # resolved to a v1 taskset or a v0 env id
-    assert config.env.taskset.id or config.id
+    assert config.env.taskset.id

{verifiers-0.3.1.dev10 → verifiers-0.3.1.dev12}/tests/v1/test_e2e.py

@@ -301,7 +301,7 @@ async def test_shared_tool_isolation(
 ):
     """A shared writable tool isolates state across concurrent rollouts and runtimes."""
     traces = await run_v1_server(
-        "scratchpad-v1",
+        "scratchpad",
         harness="null",
         runtime={"type": harness_runtime},
         output_dir=tmp_path,
@@ -584,7 +584,7 @@ async def test_kuhn_poker_self_play(run_v1, tmp_path):
     """The turn-coupled proof env: one Kuhn poker hand, both seats live interactions
     of the run's own model (self-play), refereed host-side, paid out zero-sum."""
     traces = await run_v1(
-        "kuhn-poker-v1",
+        "kuhn-poker",
         harness=None,  # both seats pin the null harness themselves
         output_dir=tmp_path,
         max_turns=8,
@@ -646,7 +646,7 @@ async def test_replay_round_trip(run_v1, tmp_path):
 
     run_dir = tmp_path / "run"
     (source,) = await run_v1(
-        "reverse-text-v1",
+        "reverse-text",
         harness="null",
         runtime={"type": "subprocess"},
         output_dir=run_dir,

{verifiers-0.3.1.dev10 → verifiers-0.3.1.dev12}/tests/v1/test_envs.py

@@ -1,6 +1,6 @@
-"""Smoke-eval every V1 example taskset in `environments/` through the `eval` CLI.
+"""Smoke-eval every example taskset in `environments/` through the `eval` CLI.
 
-Each `_v1` taskset runs with its required harness for one short, capped rollout, so a broken
+Each taskset runs with its required harness for one short, capped rollout, so a broken
 example taskset fails CI. `compact` is excluded (it's a harness, not a taskset);
 SWE/container tasksets need a docker/prime runtime and are covered by dedicated V1 e2e tests.
 """
@@ -18,15 +18,15 @@ EVAL_TIMEOUT = 600  # 10 minutes for a capped eval (-n 1 -r 1)
 ENVIRONMENTS = Path(__file__).parent.parent.parent / "environments"
 
 # V1 tasksets that aren't part of the default CI install.
-SKIP_EVAL = {"nemo_gym_weather_v1"}
+SKIP_EVAL = {"nemo_gym_weather"}
 
 # Per-run caps are seat fields; recipe envs name their own seats.
 SEATS: dict[str, tuple[str, ...]] = {
-    "code_golf_v1": ("golfer",),
-    "kuhn_poker_v1": ("player0", "player1"),
-    "openenv_wordle_v1": ("player",),
-    "proposer_solver_v1": ("proposer", "solver"),
-    "wordle_v1": ("player",),
+    "code_golf": ("golfer",),
+    "kuhn_poker": ("player0", "player1"),
+    "openenv_wordle": ("player",),
+    "proposer_solver": ("proposer", "solver"),
+    "wordle": ("player",),
 }
 
 
@@ -34,7 +34,9 @@ def v1_tasksets() -> list[str]:
     if not ENVIRONMENTS.is_dir():
         return []
     return sorted(
-        d.name for d in ENVIRONMENTS.iterdir() if d.is_dir() and d.name.endswith("_v1")
+        d.name
+        for d in ENVIRONMENTS.iterdir()
+        if d.is_dir() and d.name != "compact" and (d / "pyproject.toml").exists()
     )
 
 

verifiers-0.3.1.dev12/tests/v1/test_scoring.py

@@ -0,0 +1,101 @@
+import verifiers.v1 as vf
+from verifiers.v1.graph import MessageNode
+from verifiers.v1.types import AssistantMessage, UserMessage
+
+PLUGGED_FNS_PY = """
+async def reply_length(trace) -> float:
+    return float(len(trace.last_reply or ""))
+
+
+async def exact_match(task, trace) -> float:
+    return float(task.answer in (trace.last_reply or ""))
+
+
+async def marker(trace) -> float:
+    return 0.125
+
+
+async def two_turns(trace) -> bool:
+    return trace.num_turns >= 2
+"""
+
+
+class HookData(vf.TaskData):
+    answer: str = ""
+
+
+class HookTask(vf.Task[HookData]):
+    @vf.stop
+    async def single_turn(self, trace: vf.Trace) -> bool:
+        return trace.num_turns >= 1
+
+    @vf.reward
+    async def lcs(self, trace: vf.Trace) -> float:
+        return 0.5
+
+
+async def test_config_plugged_fns_merge_and_override(tmp_path) -> None:
+    fns = tmp_path / "fns.py"
+    fns.write_text(PLUGGED_FNS_PY)
+    config = vf.TaskConfig(
+        stops={"single_turn": vf.DecoratedFunctionConfig(fn=f"{fns}:two_turns")},
+        metrics={"reply_length": vf.DecoratedFunctionConfig(fn=f"{fns}:reply_length")},
+        rewards={
+            "exact_match": vf.RewardFunctionConfig(fn=f"{fns}:exact_match", weight=0.5),
+            "lcs": vf.RewardFunctionConfig(fn=f"{fns}:marker", weight=2.0),
+        },
+    )
+    task = HookTask(HookData(idx=0, prompt="abc", answer="cba"), config)
+    trace = vf.Trace(
+        agent=vf.AgentInfo(config=vf.AgentConfig()),
+        task=vf.TraceTask(type="HookTask", data=task.data),
+        nodes=[
+            MessageNode(parent=None, message=UserMessage(content="abc"), sampled=False),
+            MessageNode(
+                parent=0, message=AssistantMessage(content="cba"), sampled=True
+            ),
+        ],
+    )
+
+    # the plugged `single_turn` replaces the decorated one: no stop after one turn
+    (stop,) = task.hooks("stop")
+    assert stop.__name__ == "single_turn"
+    assert not await stop(trace)
+
+    await task.score(trace)
+    # `lcs` scored by the plugged marker (config wins the name clash), config weight
+    assert trace.rewards["lcs"].score == 0.125
+    assert trace.rewards["lcs"].weight == 2.0
+    assert trace.rewards["exact_match"].score == 1.0
+    assert trace.rewards["exact_match"].weight == 0.5
+    assert trace.metrics["reply_length"] == 3.0
+
+
+def test_compare_stdout_results_accepts_token_equal_text() -> None:
+    assert vf.compare_stdout_results("hello   world\n", "hello world\n")
+
+
+def test_compare_stdout_results_keeps_numeric_tolerance() -> None:
+    assert vf.compare_stdout_results("1.0001 2.0\n", "1.0002 2.0009\n")
+
+
+def test_parse_pytest_outcomes_strips_xfail_xpass_reasons() -> None:
+    output = (
+        "XFAIL tests/test_mod.py::test_xfail - known bug - still tracked\n"
+        "XPASS tests/test_mod.py::test_xpass - always xfail - unexpectedly passed\n"
+        "FAILED tests/test_mod.py::test_param[a - b] - assert left - right\n"
+        "PASSED tests/test_mod.py::test_ok"
+    )
+
+    assert vf.parse_pytest_outcomes(output) == {
+        "tests/test_mod.py::test_xfail": "XFAIL",
+        "tests/test_mod.py::test_xpass": "XPASS",
+        "tests/test_mod.py::test_param[a - b]": "FAILED",
+        "tests/test_mod.py::test_ok": "PASSED",
+    }
+
+
+def test_parse_judge_choice_uses_first_choice_after_verdict_marker() -> None:
+    response = "Final Judgment: B because it is a better answer"
+
+    assert vf.parse_judge_choice(response, choices=("A", "B")) == "B"

verifiers-0.3.1.dev12/verifiers/__init__.py

@@ -0,0 +1,103 @@
+"""The verifiers package root.
+
+The v1 stack lives in `verifiers.v1`; the classic (v0) stack lives in
+`verifiers.legacy`. The v0 modules keep answering at their pre-move paths —
+`verifiers.envs`, `verifiers.types`, `import verifiers as vf`, ... — through the
+alias finder below, so importing this package root stays side-effect free (the
+v0 surface only loads when something touches it).
+"""
+
+import sys
+from importlib import import_module
+from importlib.abc import Loader, MetaPathFinder
+from importlib.machinery import ModuleSpec
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as _version
+from importlib.util import find_spec
+from typing import TYPE_CHECKING
+
+try:
+    __version__ = _version("verifiers")
+except PackageNotFoundError:  # source tree without install metadata
+    __version__ = "0.0.0+unknown"
+
+# The v0 modules that moved under `verifiers.legacy` and stay importable at
+# their old top-level paths.
+LEGACY_MODULES = frozenset(
+    {
+        "clients",
+        "decorators",
+        "envs",
+        "errors",
+        "gepa",
+        "parsers",
+        "rubrics",
+        "scripts",
+        "serve",
+        "types",
+        "utils",
+    }
+)
+
+
+class LegacyAliasFinder(MetaPathFinder, Loader):
+    """Resolve `verifiers.<v0 module>` to `verifiers.legacy.<module>`.
+
+    The loaded module is the legacy module object itself (one instance, aliased
+    in `sys.modules` under both names), so `verifiers.types.State is
+    verifiers.legacy.types.State` and pre-move imports — including the absolute
+    ones inside the moved code — keep working. Installed at the *front* of
+    `sys.meta_path` so the path finder never re-executes an aliased package's
+    children under the old name.
+    """
+
+    _prefix = "verifiers."
+    _legacy_prefix = "verifiers.legacy."
+
+    def find_spec(self, fullname, path=None, target=None):
+        if not fullname.startswith(self._prefix) or fullname.startswith(
+            self._legacy_prefix
+        ):
+            return None
+        tail = fullname.removeprefix(self._prefix)
+        if tail.split(".", 1)[0] not in LEGACY_MODULES:
+            return None
+        try:
+            legacy_spec = find_spec(self._legacy_prefix + tail)
+        except ModuleNotFoundError:
+            legacy_spec = None
+        if legacy_spec is None:  # unknown submodule: fail like any missing import
+            return None
+        spec = ModuleSpec(
+            fullname,
+            self,
+            origin=legacy_spec.origin,
+            is_package=legacy_spec.submodule_search_locations is not None,
+        )
+        return spec
+
+    def create_module(self, spec):
+        # The already-initialized legacy module keeps its own __name__/__spec__
+        # (`module_from_spec` only fills attributes that are missing).
+        return import_module(self._legacy_prefix + spec.name.removeprefix(self._prefix))
+
+    def exec_module(self, module):
+        pass  # imported (or in progress) under its legacy name already
+
+
+if not any(isinstance(finder, LegacyAliasFinder) for finder in sys.meta_path):
+    sys.meta_path.insert(0, LegacyAliasFinder())
+
+
+def __getattr__(name: str):
+    """`vf.XMLParser`-style access forwards to the v0 surface in
+    `verifiers.legacy` (loaded on first touch). `__all__` forwards too, so
+    `from verifiers import *` keeps its pre-move meaning."""
+    if name.startswith("_") and name != "__all__":
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    legacy = import_module("verifiers.legacy")
+    return getattr(legacy, name)
+
+
+if TYPE_CHECKING:  # static view of the forwarded surface
+    from verifiers.legacy import *

{verifiers-0.3.1.dev10 → verifiers-0.3.1.dev12}/verifiers/cli/commands/build.py

@@ -2,7 +2,7 @@
 
 """Environment build command module for external hosts."""
 
-from verifiers.scripts.build import main
+from verifiers.legacy.scripts.build import main
 
 
 if __name__ == "__main__":

{verifiers-0.3.1.dev10 → verifiers-0.3.1.dev12}/verifiers/cli/commands/eval.py

@@ -2,7 +2,7 @@
 
 """Evaluation command module for external hosts."""
 
-from verifiers.scripts.eval import (
+from verifiers.legacy.scripts.eval import (
     build_extra_headers,
     build_parser,
     main,

{verifiers-0.3.1.dev10 → verifiers-0.3.1.dev12}/verifiers/cli/commands/gepa.py

@@ -2,7 +2,7 @@
 
 """GEPA command module for external hosts."""
 
-from verifiers.scripts.gepa import main
+from verifiers.legacy.scripts.gepa import main
 
 
 if __name__ == "__main__":

{verifiers-0.3.1.dev10 → verifiers-0.3.1.dev12}/verifiers/cli/commands/init.py

@@ -2,7 +2,7 @@
 
 """Environment initialization command module for external hosts."""
 
-from verifiers.scripts.init import main
+from verifiers.legacy.scripts.init import main
 
 
 if __name__ == "__main__":

{verifiers-0.3.1.dev10 → verifiers-0.3.1.dev12}/verifiers/cli/commands/install.py

@@ -2,7 +2,7 @@
 
 """Environment install command module for external hosts."""
 
-from verifiers.scripts.install import main
+from verifiers.legacy.scripts.install import main
 
 
 if __name__ == "__main__":

{verifiers-0.3.1.dev10 → verifiers-0.3.1.dev12}/verifiers/cli/commands/setup.py

@@ -1,6 +1,6 @@
 """Workspace setup command module for external hosts."""
 
-from verifiers.scripts.setup import main, run_setup
+from verifiers.legacy.scripts.setup import main, run_setup
 
 __all__ = ["main", "run_setup"]
 

{verifiers-0.3.1.dev10 → verifiers-0.3.1.dev12}/verifiers/cli/tui.py

@@ -1,6 +1,6 @@
 """TUI exports for host CLIs."""
 
-from verifiers.scripts.tui import main
+from verifiers.legacy.scripts.tui import main
 
 __all__ = ["main"]
 

{verifiers-0.3.1.dev10/verifiers → verifiers-0.3.1.dev12/verifiers/legacy}/__init__.py

@@ -109,39 +109,39 @@ __all__ = [
 ]
 
 _LAZY_IMPORTS = {
-    "Client": "verifiers.clients.client:Client",
+    "Client": "verifiers.legacy.clients.client:Client",
     "AnthropicMessagesClient": (
-        "verifiers.clients.anthropic_messages_client:AnthropicMessagesClient"
+        "verifiers.legacy.clients.anthropic_messages_client:AnthropicMessagesClient"
     ),
     "OpenAIChatCompletionsClient": (
-        "verifiers.clients.openai_chat_completions_client:OpenAIChatCompletionsClient"
+        "verifiers.legacy.clients.openai_chat_completions_client:OpenAIChatCompletionsClient"
     ),
-    "RendererClient": ("verifiers.clients.renderer_client:RendererClient"),
+    "RendererClient": ("verifiers.legacy.clients.renderer_client:RendererClient"),
     "OpenAICompletionsClient": (
-        "verifiers.clients.openai_completions_client:OpenAICompletionsClient"
+        "verifiers.legacy.clients.openai_completions_client:OpenAICompletionsClient"
     ),
     "OpenAIResponsesClient": (
-        "verifiers.clients.openai_responses_client:OpenAIResponsesClient"
+        "verifiers.legacy.clients.openai_responses_client:OpenAIResponsesClient"
     ),
-    "Environment": "verifiers.envs.environment:Environment",
-    "MultiTurnEnv": "verifiers.envs.multiturn_env:MultiTurnEnv",
-    "SingleTurnEnv": "verifiers.envs.singleturn_env:SingleTurnEnv",
-    "StatefulToolEnv": "verifiers.envs.stateful_tool_env:StatefulToolEnv",
-    "ToolEnv": "verifiers.envs.tool_env:ToolEnv",
-    "EnvGroup": "verifiers.envs.env_group:EnvGroup",
-    "JudgeRubric": "verifiers.rubrics.judge_rubric:JudgeRubric",
-    "load_environment": "verifiers.utils.env_utils:load_environment",
-    "MathRubric": "verifiers.rubrics.math_rubric:MathRubric",
-    "SandboxEnv": "verifiers.envs.sandbox_env:SandboxEnv",
-    "PythonEnv": "verifiers.envs.python_env:PythonEnv",
-    "GymEnv": "verifiers.envs.experimental.gym_env:GymEnv",
-    "CliAgentEnv": "verifiers.envs.experimental.cli_agent_env:CliAgentEnv",
-    "HarborEnv": "verifiers.envs.experimental.harbor_env:HarborEnv",
-    "MCPEnv": "verifiers.envs.experimental.mcp_env:MCPEnv",
-    "ReasoningGymEnv": "verifiers.envs.integrations.reasoninggym_env:ReasoningGymEnv",
-    "TextArenaEnv": "verifiers.envs.integrations.textarena_env:TextArenaEnv",
-    "BrowserEnv": "verifiers.envs.integrations.browser_env:BrowserEnv",
-    "OpenEnvEnv": "verifiers.envs.integrations.openenv_env:OpenEnvEnv",
+    "Environment": "verifiers.legacy.envs.environment:Environment",
+    "MultiTurnEnv": "verifiers.legacy.envs.multiturn_env:MultiTurnEnv",
+    "SingleTurnEnv": "verifiers.legacy.envs.singleturn_env:SingleTurnEnv",
+    "StatefulToolEnv": "verifiers.legacy.envs.stateful_tool_env:StatefulToolEnv",
+    "ToolEnv": "verifiers.legacy.envs.tool_env:ToolEnv",
+    "EnvGroup": "verifiers.legacy.envs.env_group:EnvGroup",
+    "JudgeRubric": "verifiers.legacy.rubrics.judge_rubric:JudgeRubric",
+    "load_environment": "verifiers.legacy.utils.env_utils:load_environment",
+    "MathRubric": "verifiers.legacy.rubrics.math_rubric:MathRubric",
+    "SandboxEnv": "verifiers.legacy.envs.sandbox_env:SandboxEnv",
+    "PythonEnv": "verifiers.legacy.envs.python_env:PythonEnv",
+    "GymEnv": "verifiers.legacy.envs.experimental.gym_env:GymEnv",
+    "CliAgentEnv": "verifiers.legacy.envs.experimental.cli_agent_env:CliAgentEnv",
+    "HarborEnv": "verifiers.legacy.envs.experimental.harbor_env:HarborEnv",
+    "MCPEnv": "verifiers.legacy.envs.experimental.mcp_env:MCPEnv",
+    "ReasoningGymEnv": "verifiers.legacy.envs.integrations.reasoninggym_env:ReasoningGymEnv",
+    "TextArenaEnv": "verifiers.legacy.envs.integrations.textarena_env:TextArenaEnv",
+    "BrowserEnv": "verifiers.legacy.envs.integrations.browser_env:BrowserEnv",
+    "OpenEnvEnv": "verifiers.legacy.envs.integrations.openenv_env:OpenEnvEnv",
 }
 
 

{verifiers-0.3.1.dev10/verifiers → verifiers-0.3.1.dev12/verifiers/legacy}/clients/__init__.py

@@ -1,17 +1,19 @@
 # ruff: noqa
 
-from verifiers.clients.anthropic_messages_client import AnthropicMessagesClient
-from verifiers.clients.client import Client
-from verifiers.clients.nemorl_chat_completions_client import (
+from verifiers.legacy.clients.anthropic_messages_client import AnthropicMessagesClient
+from verifiers.legacy.clients.client import Client
+from verifiers.legacy.clients.nemorl_chat_completions_client import (
     NeMoRLChatCompletionsClient,
 )
-from verifiers.clients.openai_chat_completions_client import OpenAIChatCompletionsClient
-from verifiers.clients.openai_chat_completions_token_client import (
+from verifiers.legacy.clients.openai_chat_completions_client import (
+    OpenAIChatCompletionsClient,
+)
+from verifiers.legacy.clients.openai_chat_completions_token_client import (
     OpenAIChatCompletionsTokenClient,
 )
-from verifiers.clients.openai_completions_client import OpenAICompletionsClient
-from verifiers.clients.openai_responses_client import OpenAIResponsesClient
-from verifiers.types import ClientConfig
+from verifiers.legacy.clients.openai_completions_client import OpenAICompletionsClient
+from verifiers.legacy.clients.openai_responses_client import OpenAIResponsesClient
+from verifiers.legacy.types import ClientConfig
 
 
 def resolve_client(client_or_config: Client | ClientConfig) -> Client:
@@ -31,7 +33,7 @@ def resolve_client(client_or_config: Client | ClientConfig) -> Client:
             case "openai_responses":
                 return OpenAIResponsesClient(client_or_config)
             case "renderer":
-                from verifiers.clients.renderer_client import RendererClient
+                from verifiers.legacy.clients.renderer_client import RendererClient
 
                 return RendererClient(client_or_config)
             case "anthropic_messages":
@@ -44,10 +46,10 @@ def resolve_client(client_or_config: Client | ClientConfig) -> Client:
 
 def __getattr__(name: str):
     if name == "RendererClient":
-        from verifiers.clients.renderer_client import RendererClient
+        from verifiers.legacy.clients.renderer_client import RendererClient
 
         return RendererClient
-    raise AttributeError(f"module 'verifiers.clients' has no attribute '{name}'")
+    raise AttributeError(f"module 'verifiers.legacy.clients' has no attribute '{name}'")
 
 
 __all__ = [

{verifiers-0.3.1.dev10/verifiers → verifiers-0.3.1.dev12/verifiers/legacy}/clients/anthropic_messages_client.py

@@ -30,9 +30,9 @@ from anthropic.types import (
     ToolParam as AnthropicToolParam,
 )
 
-from verifiers.clients.client import Client
-from verifiers.errors import EmptyModelResponseError, OverlongPromptError
-from verifiers.types import (
+from verifiers.legacy.clients.client import Client
+from verifiers.legacy.errors import EmptyModelResponseError, OverlongPromptError
+from verifiers.legacy.types import (
     AssistantMessage,
     ClientConfig,
     FinishReason,
@@ -49,7 +49,7 @@ from verifiers.types import (
     Usage,
     UserMessage,
 )
-from verifiers.utils.client_utils import setup_anthropic_client
+from verifiers.legacy.utils.client_utils import setup_anthropic_client
 
 
 ANTHROPIC_ADAPTIVE_THINKING_MODELS = {

{verifiers-0.3.1.dev10/verifiers → verifiers-0.3.1.dev12/verifiers/legacy}/clients/client.py

@@ -13,8 +13,8 @@ from anthropic import (
 from openai import AuthenticationError as OpenAIAuthenticationError
 from openai import PermissionDeniedError as OpenAIPermissionDeniedError
 
-from verifiers.errors import Error, ModelError
-from verifiers.types import (
+from verifiers.legacy.errors import Error, ModelError
+from verifiers.legacy.types import (
     ClientConfig,
     Messages,
     Response,