verifiers 0.3.2.dev64__py3-none-any.whl → 0.3.2.dev66__py3-none-any.whl

verifiers/v1/harnesses/bash/harness.py

@@ -8,7 +8,6 @@ from verifiers.v1.configs.harness import HarnessConfig
 from verifiers.v1.harness import Harness
 from verifiers.v1.harnesses.utils.launch import (
     CHAT_PROGRAM_SOURCE,
-    MCP_CHAT_PROGRAM_SOURCE,
     launch_chat_program,
 )
 from verifiers.v1.runtimes import ProgramResult, Runtime
@@ -122,7 +121,6 @@ class BashHarness(Harness[BashHarnessConfig]):
             mcp_urls,
             system_prompt,
             prompt,
-            source_with_mcp=MCP_CHAT_PROGRAM_SOURCE,
             extra_args=args,
             env=env,
             activate=False,

verifiers/v1/harnesses/browser_use/program.py

@@ -27,6 +27,7 @@ import subprocess
 import sys
 import time
 import urllib.request
+from contextlib import AsyncExitStack
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, cast
 from urllib.parse import urlsplit
@@ -226,63 +227,60 @@ async def main() -> None:
     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):
+    async with AsyncExitStack() as mcp_stack:
+        mcp_tools, dispatch, servers = await connect_mcp(config, mcp_stack, reserved)
+        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": 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,
+                    {"role": "tool", "tool_call_id": call.id, "content": content}
                 )
-            else:
-                content = f"error: unknown tool {name!r}"
-            messages.append(
-                {"role": "tool", "tool_call_id": call.id, "content": content}
-            )
 
 
 if __name__ == "__main__":

verifiers/v1/harnesses/null/harness.py

@@ -3,7 +3,6 @@ from verifiers.v1.configs.harness import HarnessConfig
 from verifiers.v1.harness import Harness
 from verifiers.v1.harnesses.utils.launch import (
     CHAT_PROGRAM_SOURCE,
-    MCP_CHAT_PROGRAM_SOURCE,
     launch_chat_program,
 )
 from verifiers.v1.runtimes import ProgramResult, Runtime
@@ -47,5 +46,4 @@ class NullHarness(Harness[NullHarnessConfig]):
             mcp_urls,
             system_prompt,
             prompt,
-            source_with_mcp=MCP_CHAT_PROGRAM_SOURCE,
         )

verifiers/v1/harnesses/utils/core.py

@@ -4,6 +4,7 @@ import argparse
 import asyncio
 import json
 import subprocess
+from contextlib import AsyncExitStack
 from pathlib import Path
 from typing import TYPE_CHECKING
 
@@ -361,35 +362,37 @@ async def main() -> None:
     if args.search:
         tools.append(SEARCH_TOOL)
         reserved.add("search")
-    if config.get("mcpServers"):
-        mcp_tools, dispatch, servers = await asyncio.wait_for(
-            connect_mcp(config, reserved), timeout=None if args.bash else 60
+    async with AsyncExitStack() as mcp_stack:
+        if config.get("mcpServers"):
+            mcp_tools, dispatch, servers = await asyncio.wait_for(
+                connect_mcp(config, mcp_stack, reserved),
+                timeout=None if args.bash else 60,
+            )
+        else:
+            mcp_tools, dispatch, servers = [], {}, {}
+        tools += mcp_tools
+        messages = (
+            [{"role": "system", "content": args.system_prompt}]
+            if args.system_prompt
+            else []
         )
-    else:
-        mcp_tools, dispatch, servers = [], {}, {}
-    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})
-    compactor = Compactor(
-        client,
-        args.model,
-        tools,
-        args.compaction,
-        args.summarize_at_tokens,
-    )
-    if compactor.enabled and compactor.threshold is None:
-        compactor.threshold = await discover_threshold(client, args.model)
-    # The initial conversation is the floor for checkpoint fallbacks: a first-turn
-    # checkpoint must never retry from an empty base.
-    compactor.note_good(messages)
-    await run_chat_loop(args, compactor, messages, dispatch, servers, tool_client)
+        if initial:
+            messages.extend(initial)
+        elif args.prompt:
+            messages.append({"role": "user", "content": args.prompt})
+        compactor = Compactor(
+            client,
+            args.model,
+            tools,
+            args.compaction,
+            args.summarize_at_tokens,
+        )
+        if compactor.enabled and compactor.threshold is None:
+            compactor.threshold = await discover_threshold(client, args.model)
+        # The initial conversation is the floor for checkpoint fallbacks: a first-turn
+        # checkpoint must never retry from an empty base.
+        compactor.note_good(messages)
+        await run_chat_loop(args, compactor, messages, dispatch, servers, tool_client)
     if tool_client is not None:
         await tool_client.aclose()
 

verifiers/v1/harnesses/utils/launch.py

@@ -29,8 +29,7 @@ CHAT_PROGRAM = (
     '# dependencies = ["openai", "mcp==2.0.0", "httpx", "httpx2", "tenacity"]\n'
     "# ///\n"
 )
-CHAT_PROGRAM_SOURCE = bundle_program(CHAT_PROGRAM, compaction, core)
-MCP_CHAT_PROGRAM_SOURCE = bundle_program(CHAT_PROGRAM, mcp, compaction, core)
+CHAT_PROGRAM_SOURCE = bundle_program(CHAT_PROGRAM, mcp, compaction, core)
 
 
 async def launch_chat_program(
@@ -45,7 +44,6 @@ async def launch_chat_program(
     system_prompt: str | None,
     prompt: str | Messages | None,
     *,
-    source_with_mcp: str | None = None,
     extra_args: Sequence[str] = (),
     env: dict[str, str] | None = None,
     activate: bool = True,
@@ -60,7 +58,6 @@ async def launch_chat_program(
     if system_prompt:
         args.append(f"--system-prompt={system_prompt}")
     if mcp_urls:
-        source = source_with_mcp or source
         args.append(
             "--mcp-config="
             + json.dumps(

verifiers/v1/harnesses/utils/mcp.py

@@ -1,11 +1,12 @@
+import asyncio
 from collections.abc import AsyncIterator, Awaitable, Callable, Sequence
 from contextlib import AsyncExitStack, asynccontextmanager, suppress
-from typing import Any, TypeVar, cast
+from typing import TYPE_CHECKING, Any, TypeVar, cast
 
-import httpx2
-from mcp import Client
-from mcp.client.streamable_http import create_mcp_http_client, streamable_http_client
-from tenacity import AsyncRetrying, stop_after_attempt, wait_exponential_jitter
+from anyio import CancelScope
+
+if TYPE_CHECKING:
+    from mcp import Client
 
 MCP_CALL_ATTEMPTS = 6
 MCP_TIMEOUT = 600.0
@@ -14,13 +15,21 @@ T = TypeVar("T")
 
 
 @asynccontextmanager
-async def mcp_client(spec: dict[str, Any]) -> AsyncIterator[Client]:
+async def mcp_client(spec: dict[str, Any]) -> AsyncIterator["Client"]:
     """Open one fresh MCP client in the caller's task.
 
     The client negotiates the newest protocol and falls back for older servers.
     Teardown failures after the body completes are suppressed so closing noise cannot
     fail or replay a call whose result is already available.
     """
+    # Bundled chat programs also run without tools; load MCP only when it is used.
+    import httpx2
+    from mcp import Client
+    from mcp.client.streamable_http import (
+        create_mcp_http_client,
+        streamable_http_client,
+    )
+
     stack = AsyncExitStack()
     try:
         http_client = await stack.enter_async_context(
@@ -39,38 +48,105 @@ async def mcp_client(spec: dict[str, Any]) -> AsyncIterator[Client]:
             await stack.aclose()
 
 
-async def with_retry(call: Callable[[], Awaitable[T]]) -> T:
-    """Run one client operation with the existing at-least-once retries."""
-    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()
-    raise RuntimeError("retrying stopped without returning or raising")
+class MCPConnection:
+    """One rollout-owned client, with operations serialized across reconnects.
+
+    The SDK's AnyIO contexts enter and exit in the owner task, even when discovery
+    runs under wait_for or a tool call is cancelled by another task.
+    """
+
+    def __init__(self, spec: dict[str, Any]):
+        # Bundled programs without MCP should not import the retry machinery.
+        from tenacity import AsyncRetrying, stop_after_attempt, wait_exponential_jitter
+
+        self.spec = spec
+        self.task: asyncio.Task[None] | None = None
+        self.ready: asyncio.Future[Client] | None = None
+        self.cancel_scope: CancelScope | None = None
+        self.lock = asyncio.Lock()
+        self.run = AsyncRetrying(
+            stop=stop_after_attempt(MCP_CALL_ATTEMPTS),
+            wait=wait_exponential_jitter(initial=0.5, max=30),
+            reraise=True,
+        ).wraps(self._run)
+
+    async def serve(
+        self, ready: asyncio.Future["Client"], cancel_scope: CancelScope
+    ) -> None:
+        stack = AsyncExitStack()
+        try:
+            stack.enter_context(cancel_scope)
+            client = await stack.enter_async_context(mcp_client(self.spec))
+            ready.set_result(client)
+            await asyncio.Future()
+        except asyncio.CancelledError:
+            pass
+        except Exception as error:  # noqa: BLE001 - deliver owner failures to the caller
+            if not ready.done():
+                ready.set_exception(error)
+        finally:
+            if not ready.done():
+                ready.cancel()
+            # Owner teardown must not replace the caller's error with cancellation.
+            with suppress(asyncio.CancelledError):
+                await stack.aclose()
+
+    async def _run(self, operation: Callable[["Client"], Awaitable[T]]) -> T:
+        await self.lock.acquire()
+        try:
+            if self.task is None or self.task.done():
+                self.ready = asyncio.get_running_loop().create_future()
+                self.cancel_scope = CancelScope()
+                self.task = asyncio.create_task(
+                    self.serve(self.ready, self.cancel_scope)
+                )
+            assert self.ready is not None
+            client = await self.ready
+            return await operation(client)
+        except BaseException as error:
+            await self.aclose(abort=isinstance(error, asyncio.CancelledError))
+            raise
+        finally:
+            self.lock.release()
+
+    async def aclose(self, *, abort: bool = False) -> None:
+        if self.task is None:
+            return
+        task, self.task = self.task, None
+        cancel_scope = self.cancel_scope
+        assert cancel_scope is not None
+        caller = asyncio.current_task()
+        assert caller is not None
+        # Stack cleanup can follow cancellation while awaiting a model or local tool.
+        if abort or caller.cancelling():
+            cancel_scope.cancel()
+        else:
+            task.cancel()
+        try:
+            await asyncio.shield(task)
+        except asyncio.CancelledError:
+            cancel_scope.cancel()
+            await asyncio.shield(task)
+            raise
 
 
 async def connect_mcp(
-    config: dict[str, Any], reserved: set[str] | None = None
+    config: dict[str, Any], stack: AsyncExitStack, reserved: set[str] | None = None
 ) -> tuple[
     list[dict[str, Any]],
     dict[str, tuple[str, str]],
-    dict[str, dict[str, Any]],
+    dict[str, MCPConnection],
 ]:
     """Enumerate MCP tools and return their schemas, dispatch map, and servers."""
     tool_schemas: list[dict[str, Any]] = []
     dispatch: dict[str, tuple[str, str]] = {}
-    servers: dict[str, dict[str, Any]] = {}
+    servers: dict[str, MCPConnection] = {}
     reserved = reserved or set()
     for name, spec in config.get("mcpServers", {}).items():
-        servers[name] = spec
-
-        async def list_tools(spec: dict[str, Any] = spec):
-            async with mcp_client(spec) as client:
-                return (await client.list_tools()).tools
-
-        for tool in await with_retry(list_tools):
+        server = servers[name] = MCPConnection(spec)
+        stack.push_async_callback(server.aclose)
+        result = await server.run(lambda client: client.list_tools())
+        for tool in result.tools:
             full = f"{name}_{tool.name}" if name else tool.name
             if full in reserved or full in dispatch:
                 raise ValueError(
@@ -111,17 +187,15 @@ def mcp_content_to_chat_content(
 
 
 async def call_mcp(
-    servers: dict[str, dict[str, Any]],
+    servers: dict[str, MCPConnection],
     dispatch: dict[str, tuple[str, str]],
     name: str,
     arguments: dict[str, Any],
 ) -> str | list[dict[str, Any]]:
-    """Call one MCP tool with a fresh client per retry attempt."""
+    """Reuse the rollout's client, reconnecting before retrying a failed call."""
     server_name, raw = dispatch[name]
 
-    async def call():
-        async with mcp_client(servers[server_name]) as client:
-            return await client.call_tool(raw, arguments)
-
-    result = await with_retry(call)
+    result = await servers[server_name].run(
+        lambda client: client.call_tool(raw, arguments)
+    )
     return mcp_content_to_chat_content(result.content)

verifiers/v1/mcp/launch.py

@@ -32,6 +32,7 @@ from verifiers.v1.runtimes import (
 )
 from verifiers.v1.runtimes.base import _ENSURE_UV
 from verifiers.v1.state import State
+from verifiers.v1.utils.aio import run_shielded
 
 if TYPE_CHECKING:
     from verifiers.v1.mcp.toolset import Toolset
@@ -188,35 +189,36 @@ async def _install_in_sandbox(server: ServerBase, runtime: Runtime) -> str:
     root = str(PurePosixPath(workdir) / ".vf-src")
     temp = str(PurePosixPath(workdir) / ".vf-tmp")
     cache = str(PurePosixPath(workdir) / ".vf-uv-cache")
-    vf, env = _verifiers_root(), Path(source_dir)
-    vf_name, vf_data = await _cached_sdist(vf)
-    if env == vf:
-        env_name, env_data = vf_name, vf_data
-    else:
-        env_name, env_data = await _cached_sdist(env)
-    vf_remote = f"{root}/{vf_name}"
-    env_remote = f"{root}/{env_name}"
-    await runtime.write(vf_remote, vf_data)
-    if env_remote != vf_remote:
-        await runtime.write(env_remote, env_data)
     venv = str(PurePosixPath(workdir) / ".vf-venv")
     root_q, temp_q, cache_q, venv_q = map(shlex.quote, (root, temp, cache, venv))
-    vf_source = shlex.quote(vf_remote)
-    env_source = shlex.quote(env_remote)
-    setup = (
-        f"set -e; mkdir -p {root_q} {temp_q} {cache_q}; "
-        f"export TMPDIR={temp_q} UV_CACHE_DIR={cache_q}; "
-        f"{_ENSURE_UV}; "
-        f"uv venv {venv_q} && "
-        f"uv pip install --python {venv_q} {vf_source} && "
-        f"uv pip install --python {venv_q} {env_source}"
-    )
-    result = await runtime.run(["sh", "-c", setup], {})
-    if result.exit_code != 0:
-        raise ToolsetError(
-            f"server {server.server_name!r} install failed in runtime: "
-            f"{(result.stderr or result.stdout).strip()[-2000:]}"
+    # Colocated servers and borrowed views install into one physical environment.
+    # Serialize its mutations and only remember sources after a successful install.
+    async with runtime._mcp_install_lock:
+        sources = dict.fromkeys((str(_verifiers_root()), source_dir))
+        pending = [source for source in sources if source not in runtime._mcp_sources]
+        if not pending:
+            return f"{venv}/bin/python"
+        setup = (
+            f"set -e; mkdir -p {root_q} {temp_q} {cache_q}; "
+            f"export TMPDIR={temp_q} UV_CACHE_DIR={cache_q}; "
+            'export PATH="$HOME/.local/bin:$PATH"; '
         )
+        if not runtime._mcp_sources:
+            # Failed installs can leave the venv behind; retain it when retrying.
+            setup += f"{_ENSURE_UV}; uv venv --allow-existing {venv_q}; "
+        # Drain remote writes and installs before cancellation releases the lock.
+        for source in pending:
+            name, data = await _cached_sdist(Path(source))
+            remote = f"{root}/{name}"
+            await run_shielded(runtime.write(remote, data))
+            setup += f"uv pip install --python {venv_q} {shlex.quote(remote)}; "
+        result = await run_shielded(runtime.run(["sh", "-c", setup], {}))
+        if result.exit_code != 0:
+            raise ToolsetError(
+                f"server {server.server_name!r} install failed in runtime: "
+                f"{(result.stderr or result.stdout).strip()[-2000:]}"
+            )
+        runtime._mcp_sources.update(pending)
     return f"{venv}/bin/python"
 
 

verifiers/v1/runtimes/base.py

@@ -155,6 +155,8 @@ class Runtime(ABC):
         self.env: dict[str, str] = {}
         self._uv_interpreters: dict[str, str] = {}
         self._uv_script_locks: dict[str, asyncio.Lock] = {}
+        self._mcp_sources: set[str] = set()
+        self._mcp_install_lock = asyncio.Lock()
         self._setup_claimed = False
         self.stopped = False
         """Whether teardown has begun (set by `stop`). A stopped runtime is dead: a rollout

{verifiers-0.3.2.dev64.dist-info → verifiers-0.3.2.dev66.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifiers
-Version: 0.3.2.dev64
+Version: 0.3.2.dev66
 Summary: Verifiers: Environments for LLM Reinforcement Learning
 Project-URL: Homepage, https://github.com/primeintellect-ai/verifiers
 Project-URL: Documentation, https://github.com/primeintellect-ai/verifiers

{verifiers-0.3.2.dev64.dist-info → verifiers-0.3.2.dev66.dist-info}/RECORD

@@ -85,10 +85,10 @@ verifiers/v1/gepa/runner.py,sha256=fGEyFzejdQKBzBbvdiTDHV3JtRhXMXMGSBU5y8C8i3w,6
 verifiers/v1/harnesses/__init__.py,sha256=0FVi-mPF36fF0vpLY4H2vbK3U_om1Svz3KgJ3i-phs0,1918
 verifiers/v1/harnesses/node.py,sha256=-lDPh30p65IETPVLkKn4yhEK49rtEGVQf9TNs7MVQYE,2133
 verifiers/v1/harnesses/bash/__init__.py,sha256=IAV4eMMqDHSl-9ANb0Q3kxmBZ22SeHZFBM448X4gQio,140
-verifiers/v1/harnesses/bash/harness.py,sha256=22c2Pn4TX-ftbqeFO1tOTbAij3RT19V2R88ph098jjE,5315
+verifiers/v1/harnesses/bash/harness.py,sha256=nsjLKFMGFSya4s9fMHiNVrO92RRCTS3VHqTK3rv3AFA,5233
 verifiers/v1/harnesses/browser_use/__init__.py,sha256=yxm2IG5TDLadxZEkX8SL26XWbcPcODXcrJfPfm1GqwU,171
 verifiers/v1/harnesses/browser_use/harness.py,sha256=eGdLDRbTF8hg4NUwU1jVJcsUei0Y-gTqbGcj3eFJ7XI,4926
-verifiers/v1/harnesses/browser_use/program.py,sha256=3dSFHSDIW3R5ZejV23sXReEKnGQjvPAAdzU-N2RrHpw,9822
+verifiers/v1/harnesses/browser_use/program.py,sha256=5g5AnRS-brYSMmHcteLf8-XDLaTDNIOjG5dym91blOc,10051
 verifiers/v1/harnesses/claude_code/__init__.py,sha256=JkZQylMSA3o1fvBx_NM41y_umuahmOSqFjTrJ2hryTw,171
 verifiers/v1/harnesses/claude_code/harness.py,sha256=Racxbs1EAH3gRwSeUptAIa3kB-EUm_nreUnHMwRUHuE,4119
 verifiers/v1/harnesses/codex/__init__.py,sha256=ocyBvlpSO8c3pT6D1ebrQohoXYESQcCyPT5kN3j1-N4,132
@@ -102,7 +102,7 @@ verifiers/v1/harnesses/mini_swe_agent/__init__.py,sha256=1OBu2Y-XqL72-dGhFdgB6sr
 verifiers/v1/harnesses/mini_swe_agent/harness.py,sha256=HKGtlDyhXDJqNtDFeb3D4JYUerIgXK6HAmyqOm1mkRo,2473
 verifiers/v1/harnesses/mini_swe_agent/program.py,sha256=Beej-JLIgSqnqIqB746oKU6kJYcynvppIbmwGa3nJJ0,167
 verifiers/v1/harnesses/null/__init__.py,sha256=XDeKOPeoXUQi9US9_Z3_yH9YaZ4EiOMKJmUtNNdtD7s,127
-verifiers/v1/harnesses/null/harness.py,sha256=RWj2I7auxYe4dJ885DhqH1MN15iUS-TKT7-gEWNrgmM,1412
+verifiers/v1/harnesses/null/harness.py,sha256=Bq19j8Bh_d4VvpFx9nwv6BKnG1tKweEk-2BSmaXWLkU,1330
 verifiers/v1/harnesses/openclaw/__init__.py,sha256=kNyfPB1sGwEf4K3mTfKN0VEyxun3SGvNpvArVKvH-x8,160
 verifiers/v1/harnesses/openclaw/harness.py,sha256=tucrQb_Osi7KAEtpyO4i55IXI5SFtLnyItB8eV4kjng,10534
 verifiers/v1/harnesses/pi/__init__.py,sha256=1mSnzOf-RdEchdeg6IHtcdobG5KIpAhuTdUIgsCIn74,117
@@ -118,10 +118,10 @@ verifiers/v1/harnesses/terminus_2/harness.py,sha256=DMTY1bzvydyjHqzmvBSBGKJsmUzY
 verifiers/v1/harnesses/terminus_2/program.py,sha256=X8MZdyItU3gbXGXnGOlJ9LWcUTnqIDaxlhkZvoRiqKY,2703
 verifiers/v1/harnesses/utils/__init__.py,sha256=eTS-Ft2HwoLiYn5u1t_KueLmaZB_W12cdYmcVsE-G5A,364
 verifiers/v1/harnesses/utils/compaction.py,sha256=DeY6CYLEsv7-vJm26sT2mRaPHu3W2ywiZhvFr_pi6Hg,10495
-verifiers/v1/harnesses/utils/core.py,sha256=_FYeBvp506JWsya0vKYbka9ZYqUwJC7Gm7fnwammwug,14993
+verifiers/v1/harnesses/utils/core.py,sha256=x3znrq2CkXmdXRCOtamhHN86fI5EaD6zr7krV6n0BnI,15221
 verifiers/v1/harnesses/utils/install.py,sha256=BDkkUVZ1brSzCrbQOvMO5mVIE2DsV2pE7rTC5yROYUw,2992
-verifiers/v1/harnesses/utils/launch.py,sha256=XlQezSmgq6X3F7q9L7UROw74BfF4oHFPgQLVbd-m7SI,3039
-verifiers/v1/harnesses/utils/mcp.py,sha256=Sss-DVMtxdE1eGEfq1ycdi1v7SBsmUU5UcpcIY6dGTY,4572
+verifiers/v1/harnesses/utils/launch.py,sha256=RqPuUY-kT2XVuLSGtXW7kRQEaP-o2KzkiJ7vcoo2neM,2883
+verifiers/v1/harnesses/utils/mcp.py,sha256=oNhKfLjAW-wScJcDIsW_HfuvKY-JkaGBBZrRLqgRK1g,7355
 verifiers/v1/interception/__init__.py,sha256=5Kvo7tcBUVaa65s9A1NiOH3CPpzw-P5btXwxB4Nbbvs,4251
 verifiers/v1/interception/base.py,sha256=Mg16Y104lyZilF9shdivdqYoqz4OYp978i_myyrulu8,2529
 verifiers/v1/interception/pool.py,sha256=sk_zcdTV8EVRuzqlYMXxon_42tSDAlFvwcyOO2EF7hw,6473
@@ -137,11 +137,11 @@ verifiers/v1/judges/reference.txt,sha256=Ej35kGXiT2uJ0LcHIeez49rCS_9uHmCQKoVdn93
 verifiers/v1/judges/rubric.py,sha256=HGQYI3xdq8I84Ce0_sDeNgk5JM597es8rOVPipjCyxU,12025
 verifiers/v1/judges/rubric.txt,sha256=3KA2ZeYYdcDweJhUGopxu9EFgARhu2aWft5S5cj8Bc8,323
 verifiers/v1/mcp/__init__.py,sha256=pm8ZWBiL1q1tY4wHvJzM_QrZ9oR8aGm-bIRWiRJsgHI,408
-verifiers/v1/mcp/launch.py,sha256=K6M8ZaoOO7wt65s93wK_9Wl7bvjeQ4C8BLkrGE149DI,23373
+verifiers/v1/mcp/launch.py,sha256=gFkAdSZpFAxj5AAmL45Rh1dAttZVzoXJQPqgfY-jcGU,23866
 verifiers/v1/mcp/server.py,sha256=Jqi8OMT8DnoZegXqM3UNNRzhVnbdrPEwx0DjOJo_K2A,13256
 verifiers/v1/mcp/toolset.py,sha256=G2wzNdEMGLXoQUcrwF0TartJkqokNPI3o7YUOAaaa6U,1007
 verifiers/v1/runtimes/__init__.py,sha256=ppc1R_sx-aMcuJSx4t99rTSjloUXI0M6EUj676-1PeY,2862
-verifiers/v1/runtimes/base.py,sha256=kPxbK-VPr4j3Ah0SYlHAMefUJpVF6jTCJkZm7TRVeAs,17376
+verifiers/v1/runtimes/base.py,sha256=VMxYMnGE_zj4k1VseTxEtKhzOZroahRnZSfvruDenEw,17468
 verifiers/v1/runtimes/limiters.py,sha256=C6cWDD4pwyFwUY4QFke3oiMXwydSNIfSbJSIglUC2kE,3062
 verifiers/v1/runtimes/modal.py,sha256=wUNik2Wul1YISausdABIMAoSaTA0MNDwKUayKxVLwAA,13342
 verifiers/v1/runtimes/prime.py,sha256=fbyR5s3WqsJNWki3eHJa83j4iobnqDugdJWm8GwEs7w,18494
@@ -189,8 +189,8 @@ verifiers/v1/utils/prime.py,sha256=UTYRjp9cbjNb6CVmBHda-1wWZAIIfxNOmTyNuT7_wL4,9
 verifiers/v1/utils/retries.py,sha256=Y2ZgrAjn-qNkRKZP_RVNL_7EK0iaRcZeCa404lpGYi4,5417
 verifiers/v1/utils/score.py,sha256=493yJVMw8teCu9JxapxMFPFzI0hNUqdo0Y2nGW4kckk,6200
 verifiers/v1/utils/version.py,sha256=-obEo_-l9-D8FLef4hYxncOe-uJpxrM1g2Hig_37Sgs,1607
-verifiers-0.3.2.dev64.dist-info/METADATA,sha256=uYX4LJNV3yeutj3Pwcw8IU3Fbz-CYNSzBwOs5vX50nY,4204
-verifiers-0.3.2.dev64.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-verifiers-0.3.2.dev64.dist-info/entry_points.txt,sha256=uqQje0TMsr7k6nXlWxlPs13Si0evb3pVCEDF6c-YL80,241
-verifiers-0.3.2.dev64.dist-info/licenses/LICENSE,sha256=v0RrUsdV3IDoZhrRce297IXS3xMHNJ-_LdLpFAUWb9k,1072
-verifiers-0.3.2.dev64.dist-info/RECORD,,
+verifiers-0.3.2.dev66.dist-info/METADATA,sha256=_cPGErluCxAPydFeyGvLRsw5QHmMadVtWvNOrud1fG0,4204
+verifiers-0.3.2.dev66.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+verifiers-0.3.2.dev66.dist-info/entry_points.txt,sha256=uqQje0TMsr7k6nXlWxlPs13Si0evb3pVCEDF6c-YL80,241
+verifiers-0.3.2.dev66.dist-info/licenses/LICENSE,sha256=v0RrUsdV3IDoZhrRce297IXS3xMHNJ-_LdLpFAUWb9k,1072
+verifiers-0.3.2.dev66.dist-info/RECORD,,