verifiers 0.2.2.dev54__tar.gz → 0.2.2.dev56__tar.gz

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

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

{verifiers-0.2.2.dev54 → verifiers-0.2.2.dev56}/pyproject.toml

@@ -234,6 +234,7 @@ markers = [
     "colocated: v1 e2e cases with a user/tool server colocated in the harness runtime",
     "null: v1 e2e cases on the null harness",
     "bash: v1 e2e cases on the bash harness",
+    "browser_use: v1 e2e cases on the browser_use harness",
     "rlm: v1 e2e cases on the rlm harness",
     "kimi_code: v1 e2e cases on the kimi-code harness",
     "pi: v1 e2e cases on the pi harness",

{verifiers-0.2.2.dev54 → verifiers-0.2.2.dev56}/tests/v1/test_e2e.py

@@ -118,6 +118,26 @@ async def test_single_turn(run_v1, harness, harness_runtime, tmp_path):
         assert call.time.duration > 0
 
 
+@pytest.mark.e2e
+@pytest.mark.browser_use
+@pytest.mark.docker
+async def test_browser_use(run_v1, tmp_path):
+    """The browser_use harness runs in an explicitly browser-capable runtime."""
+    image = (
+        "mcr.microsoft.com/playwright/python:v1.61.0-noble@"
+        "sha256:a9731514f24121d1dcd25d58d0a38146646d290a5998fd80d3e533e7b5e21c69"
+    )
+    (trace,) = await run_v1(
+        "echo-v1",
+        harness="browser_use",
+        runtime={"type": "docker", "image": image},
+        output_dir=tmp_path,
+        max_turns=2,
+    )
+    assert trace.ok
+    assert trace.reward == 1.0
+
+
 @pytest.mark.e2e
 @pytest.mark.parametrize("harness_runtime", USER_RUNTIMES, indirect=True)
 async def test_user(run_v1, harness_runtime, tmp_path):

{verifiers-0.2.2.dev54 → verifiers-0.2.2.dev56}/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

{verifiers-0.2.2.dev54 → verifiers-0.2.2.dev56}/verifiers/v1/harnesses/__init__.py

@@ -1,4 +1,8 @@
 from verifiers.v1.harnesses.bash import BashHarness, BashHarnessConfig
+from verifiers.v1.harnesses.browser_use import (
+    BrowserUseHarness,
+    BrowserUseHarnessConfig,
+)
 from verifiers.v1.harnesses.claude_code import (
     ClaudeCodeHarness,
     ClaudeCodeHarnessConfig,
@@ -18,6 +22,8 @@ from verifiers.v1.harnesses.terminus_2 import Terminus2Harness, Terminus2Harness
 __all__ = [
     "BashHarness",
     "BashHarnessConfig",
+    "BrowserUseHarness",
+    "BrowserUseHarnessConfig",
     "ClaudeCodeHarness",
     "ClaudeCodeHarnessConfig",
     "CodexHarness",

verifiers-0.2.2.dev56/verifiers/v1/harnesses/browser_use/__init__.py

@@ -0,0 +1,6 @@
+from verifiers.v1.harnesses.browser_use.harness import (
+    BrowserUseHarness,
+    BrowserUseHarnessConfig,
+)
+
+__all__ = ["BrowserUseHarness", "BrowserUseHarnessConfig"]

verifiers-0.2.2.dev56/verifiers/v1/harnesses/browser_use/harness.py

@@ -0,0 +1,125 @@
+import json
+from pathlib import Path
+from typing import Literal
+
+from pydantic import model_validator
+
+from verifiers.v1.clients import ModelContext
+from verifiers.v1.configs.harness import HarnessConfig
+from verifiers.v1.dialects.chat import message_to_wire
+from verifiers.v1.harness import Harness
+from verifiers.v1.runtimes import ProgramResult, Runtime
+from verifiers.v1.task import TaskData
+from verifiers.v1.trace import Trace
+
+PROGRAM_SOURCE = (Path(__file__).resolve().parent / "program.py").read_text()
+
+# The helper names and persistence rules the model needs to use the local tool.
+BROWSER_SYSTEM_PROMPT = """You are a browser automation agent. Your `browser` tool executes Python code that controls a real Chromium over CDP through browser-harness; its helpers are pre-imported.
+
+Rules of the tool:
+- Each call runs in a fresh Python process: variables do NOT persist between calls. The browser does persist — tabs, cookies, and page state carry over.
+- Use print() for anything you want to see. Filter in Python before printing; a raw AX tree or DOM dump is huge.
+- The first navigation is new_tab(url), not goto_url(url). After navigating, call wait_for_load().
+
+Core helpers: new_tab(url), goto_url(url), page_info(), js(expression), click_at_xy(x, y), type_text(text), press_key(key), fill_input(selector, text), scroll(x, y, dy), wait_for_load(), wait_for_element(selector), wait_for_network_idle(), list_tabs(), switch_tab(target), close_tab(), ensure_real_tab(), capture_screenshot(path), upload_file(selector, path), and raw cdp("Domain.method", ...).
+
+Finding elements: prefer the accessibility tree over screenshots. cdp("Accessibility.getFullAXTree")["nodes"] has every element's role, name, and backendDOMNodeId — filter in Python before printing. For coordinates: q = cdp("DOM.getBoxModel", backendNodeId=n)["model"]["content"]; x, y = sum(q[0::2])/4, sum(q[1::2])/4, then click_at_xy(x, y) and verify with a targeted js(...) or page_info() check. Fall back to js(...) over the DOM when the AX tree lacks the element."""
+
+
+class BrowserUseHarnessConfig(HarnessConfig):
+    browser: Literal["chromium", "cdp"] = "chromium"
+    """`chromium` launches locally; `cdp` attaches to `cdp_url` without owning it."""
+
+    cdp_url: str | None = None
+    """Rollout-scoped HTTP or WebSocket endpoint used with `browser = "cdp"`."""
+
+    @model_validator(mode="after")
+    def _require_cdp_url_iff_cdp(self) -> "BrowserUseHarnessConfig":
+        if self.browser == "cdp" and not self.cdp_url:
+            raise ValueError(
+                "browser='cdp' needs cdp_url set to a CDP endpoint to attach to"
+            )
+        if self.browser != "cdp" and self.cdp_url:
+            raise ValueError(
+                f"cdp_url is only valid with browser='cdp', not browser={self.browser!r}"
+            )
+        return self
+
+
+class BrowserUseHarness(Harness[BrowserUseHarnessConfig]):
+    APPENDS_SYSTEM_PROMPT = True
+    SUPPORTS_MCP = True
+    SUPPORTS_RESUME = True
+    # The browser tool executes model-authored Python through a third-party daemon.
+    NEEDS_CONTAINER = True
+
+    async def setup(self, runtime: Runtime) -> None:
+        await runtime.prepare_uv_script(PROGRAM_SOURCE, self.config.resolved_env)
+
+    async def launch(
+        self,
+        ctx: ModelContext,
+        trace: Trace,
+        runtime: Runtime,
+        endpoint: str,
+        secret: str,
+        mcp_urls: dict[str, str],
+        data: TaskData,
+    ) -> ProgramResult:
+        system_prompt, prompt = self.resolve_prompt(data)
+        system_prompt = "\n\n".join(
+            p for p in (BROWSER_SYSTEM_PROMPT, system_prompt) if p
+        )
+        # Default resume replays the transcript. If there was no task system
+        # prompt, that transcript already contains this harness prompt.
+        replaying_browser_prompt = (
+            data.system_prompt is None
+            and prompt is not None
+            and not isinstance(prompt, str)
+            and any(
+                message.role == "system" and message.content == BROWSER_SYSTEM_PROMPT
+                for message in prompt
+            )
+        )
+        env = {**self.config.resolved_env}
+        state = f".vf-browser-{trace.id}"
+        args = [
+            f"--base-url={endpoint}",
+            f"--api-key={secret}",
+            f"--model={ctx.model}",
+            f"--browser={self.config.browser}",
+            # A resumed segment reuses this trace's browser and profile.
+            f"--state-dir={state}",
+        ]
+        if not replaying_browser_prompt:
+            args.append(f"--system-prompt={system_prompt}")
+        if self.config.cdp_url:
+            args.append(f"--cdp-url={self.config.cdp_url}")
+        if mcp_urls:
+            # The program connects to the tool servers over HTTP; hand it a standard
+            # `mcpServers` URL config (the `mcp` client itself comes from the uv deps).
+            args.append(
+                "--mcp-config="
+                + json.dumps(
+                    {
+                        "mcpServers": {
+                            name: {"url": url} for name, url in mcp_urls.items()
+                        }
+                    }
+                )
+            )
+        if isinstance(prompt, str):
+            args.append(f"--prompt={prompt}")
+        elif prompt is not None:
+            # Base64 images can exceed exec limits, so hand Messages off through a file.
+            path = f".vf-initial-messages-{trace.id}.json"
+            await runtime.write(
+                path,
+                json.dumps([message_to_wire(m) for m in prompt]).encode(),
+            )
+            args.append(f"--initial-messages-file={path}")
+        program = await runtime.prepare_uv_script(
+            PROGRAM_SOURCE, self.config.resolved_env
+        )
+        return await runtime.run_program([*program, *args], env)

verifiers-0.2.2.dev56/verifiers/v1/harnesses/browser_use/program.py

@@ -0,0 +1,402 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "browser-harness==0.1.8",
+#     "openai",
+#     "mcp>=1.24.0,<2",
+#     "httpx",
+#     "tenacity",
+# ]
+# ///
+"""A chat loop whose one local tool drives a real Chromium over CDP.
+
+Each tool call pipes the model's code to browser-harness, whose daemon holds the
+CDP connection and pre-imports its page helpers. `chromium` launches and owns a
+local browser; `cdp` attaches to an HTTP or WebSocket endpoint it does not own.
+Trace-scoped state preserves tabs across resume and records owned process IDs.
+"""
+
+import argparse
+import asyncio
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import time
+import urllib.request
+from contextlib import AsyncExitStack, asynccontextmanager, suppress
+from pathlib import Path
+from typing import Any, cast
+from urllib.parse import urlsplit
+
+import httpx
+from openai import AsyncOpenAI
+from tenacity import AsyncRetrying, stop_after_attempt, wait_exponential_jitter
+
+MCP_CALL_ATTEMPTS = 6
+MCP_TIMEOUT = httpx.Timeout(600.0, connect=5.0)  # the OpenAI SDK client defaults
+
+BROWSER_TOOL_TIMEOUT = 3600
+"""Matches the bash harness's command timeout."""
+
+BROWSER_READY_TIMEOUT = 60
+"""The documented Playwright image announced CDP in under one second from a
+cold container; one minute leaves ample runtime startup headroom."""
+
+_DEVTOOLS_LINE = re.compile(r"DevTools listening on ws://127\.0\.0\.1:(\d+)/")
+
+BROWSER_TOOL = {
+    "type": "function",
+    "function": {
+        "name": "browser",
+        "description": (
+            "Execute Python code that drives the browser through browser-harness. "
+            "Helpers are pre-imported; use print() to see values. Each call runs in "
+            "a fresh process: Python variables do not persist between calls, but the "
+            "browser (tabs, cookies, page state) does."
+        ),
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "code": {
+                    "type": "string",
+                    "description": "The Python code to execute.",
+                }
+            },
+            "required": ["code"],
+        },
+    },
+}
+
+
+def find_browser() -> str:
+    """The Chromium binary to launch, where a machine keeps one.
+
+    `PLAYWRIGHT_BROWSERS_PATH` before PATH: an image that installs browsers
+    through Playwright puts nothing on PATH.
+    """
+    for key in ("BH_CHROME_PATH", "CHROME_PATH"):
+        candidate = os.environ.get(key)
+        if candidate and os.access(candidate, os.X_OK):
+            return candidate
+    registry = os.environ.get("PLAYWRIGHT_BROWSERS_PATH")
+    if registry:
+        builds = sorted(Path(registry).glob("chromium-*/chrome-linux*/chrome"))
+        if builds:
+            return str(builds[-1])
+    for name in (
+        "google-chrome-stable",
+        "google-chrome",
+        "chromium",
+        "chromium-browser",
+    ):
+        found = shutil.which(name)
+        if found:
+            return found
+    raise SystemExit(
+        "no Chromium/Chrome found; run on a browser-capable image "
+        "(e.g. mcr.microsoft.com/playwright/python) or set BH_CHROME_PATH"
+    )
+
+
+def _endpoint_alive(endpoint: str) -> bool:
+    try:
+        # browser-harness uses five seconds for this same DevTools HTTP probe.
+        urllib.request.urlopen(f"{endpoint}/json/version", timeout=5).close()
+        return True
+    except OSError:
+        return False
+
+
+def ensure_chromium(state_dir: Path) -> str:
+    """Reuse this trace's live Chromium or launch it."""
+    endpoint_file = state_dir / "cdp-endpoint"
+    if endpoint_file.exists():
+        endpoint = endpoint_file.read_text().strip()
+        if endpoint and _endpoint_alive(endpoint):
+            return endpoint
+
+    profile = state_dir / "profile"
+    profile.mkdir(parents=True, exist_ok=True)
+    log = state_dir / "browser.log"
+    with open(log, "wb") as stderr:
+        browser = subprocess.Popen(
+            [
+                find_browser(),
+                "--remote-debugging-port=0",
+                f"--user-data-dir={profile}",
+                "--headless",
+                "--no-first-run",
+                "--no-default-browser-check",
+                "--disable-dev-shm-usage",
+                "--no-sandbox",
+            ],
+            stdout=subprocess.DEVNULL,
+            stderr=stderr,
+            stdin=subprocess.DEVNULL,
+            start_new_session=True,
+        )
+        deadline = time.monotonic() + BROWSER_READY_TIMEOUT
+        while time.monotonic() < deadline and browser.poll() is None:
+            output = log.read_text(errors="replace")
+            if match := _DEVTOOLS_LINE.search(output):
+                endpoint = f"http://127.0.0.1:{match.group(1)}"
+                endpoint_file.write_text(endpoint)
+                return endpoint
+            time.sleep(0.1)
+        if browser.poll() is None:
+            browser.kill()
+        browser.wait()
+    tail = log.read_text(errors="replace")[-2000:]
+    raise SystemExit(
+        f"browser did not announce a DevTools port within {BROWSER_READY_TIMEOUT}s: "
+        f"{tail or '<no browser output>'}"
+    )
+
+
+def run_browser(code: str, env: dict[str, str]) -> str:
+    """Run model code through the pinned browser-harness CLI."""
+    try:
+        result = subprocess.run(
+            [sys.executable, "-m", "browser_harness.run"],
+            input=code,
+            capture_output=True,
+            text=True,
+            timeout=BROWSER_TOOL_TIMEOUT,
+            env=env,
+            check=False,
+        )
+        return (result.stdout + result.stderr) or "(no output)"
+    except Exception as e:  # noqa: BLE001 - tool failures are returned to the model
+        return f"error: {e}"
+
+
+async def chat(
+    client: AsyncOpenAI,
+    model: str,
+    messages: list[dict[str, Any]],
+    tools: list[dict[str, Any]],
+):
+    completion = await client.chat.completions.create(
+        model=model,
+        messages=cast(Any, messages),
+        tools=cast(Any, tools or None),
+    )
+    return completion.choices[0].message
+
+
+@asynccontextmanager
+async def mcp_session(spec: dict):
+    """One fresh streamable-HTTP session to an MCP server, opened and closed within the caller's
+    task so AnyIO cancellation scopes stay correctly nested. A teardown failure after the body
+    completed is swallowed — the result is already in hand, and closing noise must not fail (or
+    replay) an already-answered call."""
+    from mcp import ClientSession
+    from mcp.client.streamable_http import (
+        create_mcp_http_client,
+        streamable_http_client,
+    )
+
+    stack = AsyncExitStack()
+    try:
+        http_client = await stack.enter_async_context(
+            create_mcp_http_client(
+                headers=spec.get("headers") or None, timeout=MCP_TIMEOUT
+            )
+        )
+        read, write, *_ = await stack.enter_async_context(
+            streamable_http_client(spec["url"], http_client=http_client)
+        )
+        session = await stack.enter_async_context(ClientSession(read, write))
+        await session.initialize()
+        yield session
+    finally:
+        with suppress(Exception):
+            await stack.aclose()
+
+
+async def with_retry(call):
+    """Run one session-scoped operation, retrying transient failures with backoff. A call whose
+    response was lost may be replayed — MCP has no idempotency key, so tools should tolerate
+    at-least-once delivery (a tool that fails reports through its result, not an exception)."""
+    async for attempt in AsyncRetrying(
+        stop=stop_after_attempt(MCP_CALL_ATTEMPTS),
+        wait=wait_exponential_jitter(initial=0.5, max=30),
+        reraise=True,
+    ):
+        with attempt:
+            return await call()
+
+
+async def connect_mcp(
+    config: dict, reserved: set[str]
+) -> tuple[list[dict], dict, dict]:
+    """Enumerate each configured MCP server's tools (a streamable-HTTP `url`); return (tool schemas,
+    dispatch mapping `<server>_<tool>` -> (server name, raw tool name), servers mapping name -> spec).
+    No session is held — a stateless-HTTP server is reconnected per call."""
+    tool_schemas: list[dict] = []
+    dispatch: dict[str, tuple] = {}
+    servers: dict[str, dict] = {}
+    for name, spec in config.get("mcpServers", {}).items():
+        servers[name] = spec
+
+        async def list_tools(spec: dict = spec):
+            async with mcp_session(spec) as session:
+                return (await session.list_tools()).tools
+
+        for tool in await with_retry(list_tools):
+            # A server named "" (TOOL_PREFIX = None) advertises its tools bare.
+            full = f"{name}_{tool.name}" if name else tool.name
+            if full in reserved or full in dispatch:
+                raise ValueError(
+                    f"duplicate tool name {full!r}; keep MCP tool names qualified"
+                )
+            tool_schemas.append(
+                {
+                    "type": "function",
+                    "function": {
+                        "name": full,
+                        "description": tool.description or "",
+                        "parameters": tool.inputSchema,
+                    },
+                }
+            )
+            dispatch[full] = (name, tool.name)
+    return tool_schemas, dispatch, servers
+
+
+def mcp_content_to_chat_content(blocks) -> str | list[dict]:
+    parts = []
+    for block in blocks:
+        if block.type == "text":
+            parts.append({"type": "text", "text": block.text})
+        elif block.type == "image":
+            url = f"data:{block.mimeType};base64,{block.data}"
+            parts.append({"type": "image_url", "image_url": {"url": url}})
+        else:
+            parts.append({"type": "text", "text": str(block)})
+    if not parts:
+        return str(blocks)
+    if all(part["type"] == "text" for part in parts):
+        return "\n".join(str(part["text"]) for part in parts)
+    return parts
+
+
+async def call_mcp(
+    servers: dict, dispatch: dict, name: str, arguments: dict
+) -> str | list[dict]:
+    """Call a tool on a fresh session per attempt — see `with_retry` for the replay semantics.
+    The result is converted outside the retry so a conversion failure fails once."""
+    server_name, raw = dispatch[name]
+
+    async def call():
+        async with mcp_session(servers[server_name]) as session:
+            return await session.call_tool(raw, arguments)
+
+    result = await with_retry(call)
+    return mcp_content_to_chat_content(result.content)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--base-url", required=True)
+    parser.add_argument("--api-key", required=True)
+    parser.add_argument("--model", required=True)
+    parser.add_argument("--state-dir", required=True)
+    parser.add_argument("--browser", default="chromium")
+    parser.add_argument("--cdp-url", default="")
+    parser.add_argument("--system-prompt", default="")
+    parser.add_argument("--prompt", default="")
+    parser.add_argument("--initial-messages-file", default="")
+    parser.add_argument("--mcp-config", default="")
+    return parser.parse_args()
+
+
+async def main() -> None:
+    args = parse_args()
+    initial = []
+    if args.initial_messages_file:
+        path = Path(args.initial_messages_file)
+        payload = path.read_bytes()
+        path.unlink()
+        initial = json.loads(payload)
+    state_dir = Path(args.state_dir)
+    state_dir.mkdir(parents=True, exist_ok=True)
+    endpoint = (
+        ensure_chromium(state_dir) if args.browser == "chromium" else args.cdp_url
+    )
+    browser_env = {
+        **os.environ,
+        "BH_HOME": str(state_dir / "bh-home"),
+        "BH_TELEMETRY": "0",
+        (
+            "BU_CDP_WS" if urlsplit(endpoint).scheme in {"ws", "wss"} else "BU_CDP_URL"
+        ): endpoint,
+    }
+    client = AsyncOpenAI(base_url=args.base_url, api_key=args.api_key)
+    config = json.loads(args.mcp_config or "{}")
+    tools = [BROWSER_TOOL]
+    reserved = {"browser"}
+    mcp_tools, dispatch, servers = (
+        await connect_mcp(config, reserved)
+        if config.get("mcpServers")
+        else ([], {}, {})
+    )
+    tools += mcp_tools
+    messages = (
+        [{"role": "system", "content": args.system_prompt}]
+        if args.system_prompt
+        else []
+    )
+    if initial:
+        messages.extend(initial)
+    elif args.prompt:
+        messages.append({"role": "user", "content": args.prompt})
+    while True:
+        message = await chat(client, args.model, messages, tools)
+        messages.append(message.model_dump(exclude_none=True))
+        if not message.tool_calls:
+            break
+        for call in message.tool_calls:
+            name = call.function.name
+            try:
+                tool_args = json.loads(call.function.arguments or "{}")
+            except json.JSONDecodeError as e:
+                messages.append(
+                    {
+                        "role": "tool",
+                        "tool_call_id": call.id,
+                        "content": f"error: invalid JSON in tool arguments ({e}); resend the call with valid JSON",
+                    }
+                )
+                continue
+            # Valid JSON can still be a non-object (`[]`, `42`, `null`); the `.get(...)` calls
+            # below assume a dict, so reject anything else as a tool error rather than crashing.
+            if not isinstance(tool_args, dict):
+                messages.append(
+                    {
+                        "role": "tool",
+                        "tool_call_id": call.id,
+                        "content": f"error: tool arguments must be a JSON object, got {type(tool_args).__name__}; resend as an object",
+                    }
+                )
+                continue
+            if name in dispatch:
+                content = await call_mcp(servers, dispatch, name, tool_args)
+            elif name == "browser":
+                content = await asyncio.to_thread(
+                    run_browser,
+                    tool_args.get("code", ""),
+                    browser_env,
+                )
+            else:
+                content = f"error: unknown tool {name!r}"
+            messages.append(
+                {"role": "tool", "tool_call_id": call.id, "content": content}
+            )
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{verifiers-0.2.2.dev54 → verifiers-0.2.2.dev56}/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.