verifiers 0.2.2.dev89__py3-none-any.whl → 0.2.2.dev91__py3-none-any.whl

verifiers/v1/acp/__init__.py

@@ -46,6 +46,7 @@ class ACP:
         command: list[str],
         prompt: str | Messages | None,
         system_prompt: str | None = None,
+        session_meta: dict | None = None,
     ) -> "ACPHarnessSession":
         """Create a persistent ACP-backed handle owned by one rollout."""
         return ACPHarnessSession(
@@ -61,6 +62,7 @@ class ACP:
             command=command,
             prompt=prompt,
             system_prompt=system_prompt,
+            session_meta=session_meta,
         )
 
     async def run(
@@ -73,6 +75,7 @@ class ACP:
         mcp_urls: dict[str, str] | None = None,
         system_prompt: str | None = None,
         session_path: str | None = None,
+        session_meta: dict | None = None,
         allow_empty_tool_reply: bool = False,
     ) -> ProgramResult:
         """Run one ACP segment without retaining its process."""
@@ -84,6 +87,7 @@ class ACP:
             mcp_urls=mcp_urls,
             system_prompt=system_prompt,
             session_path=session_path,
+            session_meta=session_meta,
             allow_empty_tool_reply=allow_empty_tool_reply,
         )
 
@@ -97,6 +101,7 @@ class ACP:
         mcp_urls: dict[str, str] | None = None,
         system_prompt: str | None = None,
         session_path: str | None = None,
+        session_meta: dict | None = None,
         allow_empty_tool_reply: bool = False,
     ) -> ProgramResult:
         if prompt is None:
@@ -112,6 +117,7 @@ class ACP:
             "mcp_urls": mcp_urls or {},
             "system_prompt": system_prompt or "",
             "session_path": session_path,
+            "session_meta": session_meta or {},
             "allow_empty_tool_reply": allow_empty_tool_reply,
         }
         program = await runtime.prepare_uv_script(
@@ -175,12 +181,14 @@ class ACPHarnessSession(HarnessSession):
         command: list[str],
         prompt: str | Messages | None,
         system_prompt: str | None,
+        session_meta: dict | None,
     ) -> None:
         super().__init__(harness, ctx, trace, runtime, endpoint, secret, mcp_urls, data)
         self.env = env
         self.command = command
         self.prompt = prompt
         self.system_prompt = system_prompt
+        self.session_meta = session_meta or {}
         self._process: RuntimeProcess | None = None
         self._reader: _PacketReader | None = None
         self._stderr_tail = bytearray()
@@ -221,6 +229,7 @@ class ACPHarnessSession(HarnessSession):
             "mcp_urls": self.mcp_urls,
             "system_prompt": self.system_prompt or "",
             "session_path": None,
+            "session_meta": self.session_meta,
         }
         async with self._lock:
             if self._closed:

verifiers/v1/acp/runner.py

@@ -196,28 +196,38 @@ async def run_once(config: dict) -> str:
         *command[1:],
         env=os.environ.copy(),
         transport_kwargs={"stderr": None},
-    ) as (connection, _process):
+    ) as agent_process:
+        connection = agent_process[0]
         initialized = await connection.initialize(
             protocol_version=PROTOCOL_VERSION,
             client_capabilities=ClientCapabilities(),
         )
         capabilities = initialized.agent_capabilities
         session_path = Path(config["session_path"]) if config["session_path"] else None
+        session_meta = config["session_meta"]
         is_new = session_path is None or not session_path.exists()
         servers = mcp_servers(config)
         if is_new:
-            session = await connection.new_session(cwd=os.getcwd(), mcp_servers=servers)
+            session = await connection.new_session(
+                cwd=os.getcwd(), mcp_servers=servers, **session_meta
+            )
             session_id = session.session_id
         else:
             session_id = session_path.read_text().strip()
             session_capabilities = capabilities and capabilities.session_capabilities
             if session_capabilities and session_capabilities.resume is not None:
                 await connection.resume_session(
-                    cwd=os.getcwd(), session_id=session_id, mcp_servers=servers
+                    cwd=os.getcwd(),
+                    session_id=session_id,
+                    mcp_servers=servers,
+                    **session_meta,
                 )
             elif capabilities and capabilities.load_session:
                 await connection.load_session(
-                    cwd=os.getcwd(), session_id=session_id, mcp_servers=servers
+                    cwd=os.getcwd(),
+                    session_id=session_id,
+                    mcp_servers=servers,
+                    **session_meta,
                 )
             else:
                 raise RuntimeError("ACP agent does not support resuming sessions")
@@ -251,12 +261,13 @@ class LiveACPSession:
         self.command: list[str] | None = None
         self.server_urls: dict[str, str] | None = None
         self.system_prompt: str | None = None
+        self.session_meta: dict | None = None
         self.is_new = True
 
     async def start(self, config: dict) -> None:
         command = config["command"]
         try:
-            self.connection, _process = await self.stack.enter_async_context(
+            agent_process = await self.stack.enter_async_context(
                 spawn_agent_process(
                     self.client,
                     command[0],
@@ -265,13 +276,16 @@ class LiveACPSession:
                     transport_kwargs={"stderr": None},
                 )
             )
+            self.connection = agent_process[0]
             initialized = await self.connection.initialize(
                 protocol_version=PROTOCOL_VERSION,
                 client_capabilities=ClientCapabilities(),
             )
             self.capabilities = initialized.agent_capabilities
             session = await self.connection.new_session(
-                cwd=os.getcwd(), mcp_servers=mcp_servers(config)
+                cwd=os.getcwd(),
+                mcp_servers=mcp_servers(config),
+                **config["session_meta"],
             )
         except BaseException:
             with suppress(BaseException):
@@ -282,6 +296,7 @@ class LiveACPSession:
         self.command = command
         self.server_urls = config["mcp_urls"]
         self.system_prompt = config["system_prompt"]
+        self.session_meta = config["session_meta"]
         self.is_new = True
 
     async def run(self, config: dict) -> str:
@@ -291,6 +306,7 @@ class LiveACPSession:
             config["command"] != self.command
             or config["mcp_urls"] != self.server_urls
             or config["system_prompt"] != self.system_prompt
+            or config["session_meta"] != self.session_meta
         ):
             raise RuntimeError("ACP session configuration changed")
         assert self.session_id is not None

verifiers/v1/harnesses/claude_code/harness.py

@@ -1,56 +1,116 @@
-"""Run Claude Code against interception as an Anthropic Messages client."""
+"""Run Claude Code through the Claude Agent SDK ACP adapter."""
 
-import json
 import shlex
 
-from pydantic import Field
-
+from verifiers.v1.acp import ACP
 from verifiers.v1.clients import ModelContext
 from verifiers.v1.configs.harness import HarnessConfig
-from verifiers.v1.harness import Harness
+from verifiers.v1.harness import Harness, HarnessSession
+from verifiers.v1.harnesses.node import NODE_BIN_DIR, ensure_node
 from verifiers.v1.runtimes import ProgramResult, Runtime
 from verifiers.v1.task import TaskData
 from verifiers.v1.trace import Trace
 
-CLAUDE_HOME = "/tmp/vf-claude-code-{version}"
-CLAUDE_BIN = f"{CLAUDE_HOME}/.local/bin/claude"
-CLAUDE_CONFIG_DIR = ".vf-claude"
-SKILLS_DIR = f"{CLAUDE_CONFIG_DIR}/skills"
-INSTALL = """
+CLAUDE_ACP_DIR = "/var/tmp/vf-claude-agent-acp"
+PACKAGES_DIR = f"{CLAUDE_ACP_DIR}/packages"
+ACP_VERSION = "0.63.0"
+ACP_BIN = f"{PACKAGES_DIR}/node_modules/.bin/claude-agent-acp"
+ACP_COMMAND = [f"{NODE_BIN_DIR}/node", ACP_BIN]
+CLAUDE_CONFIG_ROOT = ".vf-claude"
+SKILLS_DIR = ".claude/skills"
+ACP_INSTALL = r"""
 set -e
-command -v curl >/dev/null || (apt-get update -qq && apt-get install -y -qq curl ca-certificates >/dev/null)
-curl -fsSL https://claude.ai/install.sh | HOME={home} bash -s {version}
+export PATH="/var/tmp/vf-node/bin:$PATH"
+if [ "$(cat /var/tmp/vf-claude-agent-acp/.version 2>/dev/null)" = "$VF_CLAUDE_ACP_VERSION" ] \
+    && [ -x /var/tmp/vf-claude-agent-acp/packages/node_modules/.bin/claude-agent-acp ]; then
+    exit 0
+fi
+npm install --prefix /var/tmp/vf-claude-agent-acp/packages --ignore-scripts --no-audit --no-fund \
+    --omit=dev \
+    "@agentclientprotocol/claude-agent-acp@$VF_CLAUDE_ACP_VERSION" >/dev/null
+printf %s "$VF_CLAUDE_ACP_VERSION" > /var/tmp/vf-claude-agent-acp/.version
 """
 
+CLAUDE_ACP = ACP()
+
 
 class ClaudeCodeHarnessConfig(HarnessConfig):
-    version: str = Field(default="2.1.214", pattern=r"^[A-Za-z0-9._+-]+$")
-    """Claude Code release to install; pinned for reproducibility."""
+    pass
 
 
 class ClaudeCodeHarness(Harness[ClaudeCodeHarnessConfig]):
     APPENDS_SYSTEM_PROMPT = True
     SUPPORTS_MCP = True
-    # images would require streaming inputs
-    SUPPORTS_RESUME = False
+    SUPPORTS_RESUME = True
     SUPPORTS_SKILLS = True
 
     async def setup(self, runtime: Runtime) -> None:
         await self.install_skills(runtime, SKILLS_DIR)
-        home = CLAUDE_HOME.format(version=self.config.version)
-        binary = CLAUDE_BIN.format(version=self.config.version)
-        script = INSTALL.format(version=self.config.version, home=home)
-        # Cache the pinned binary across local rollouts; Linux has flock, macOS has lockf.
-        install = shlex.quote(f"[ -x {binary} ] || ({script})")
-        guarded = (
-            f"mkdir -p {home} && "
-            f'"$(command -v flock || command -v lockf)" {home}/install.lock '
-            f"bash -o pipefail -c {install}"
+        await ensure_node(runtime)
+        acp_guarded = (
+            f"mkdir -p {CLAUDE_ACP_DIR} && "
+            f'"$(command -v flock || command -v lockf)" {CLAUDE_ACP_DIR}/install.lock '
+            f"sh -c {shlex.quote(ACP_INSTALL)}"
+        )
+        acp_result = await runtime.run(
+            ["sh", "-c", acp_guarded],
+            {
+                **self.config.resolved_env,
+                "VF_CLAUDE_ACP_VERSION": ACP_VERSION,
+            },
+        )
+        if acp_result.exit_code != 0:
+            detail = (acp_result.stderr or acp_result.stdout).strip()[-500:]
+            raise RuntimeError(f"Claude Agent ACP install failed: {detail}")
+        await CLAUDE_ACP.setup(self, runtime)
+
+    async def session(
+        self,
+        ctx: ModelContext,
+        trace: Trace,
+        runtime: Runtime,
+        endpoint: str,
+        secret: str,
+        mcp_urls: dict[str, str],
+        data: TaskData,
+    ) -> HarnessSession:
+        if not runtime.supports_live_processes:
+            return await super().session(
+                ctx, trace, runtime, endpoint, secret, mcp_urls, data
+            )
+        system_prompt, prompt = self.resolve_prompt(data)
+        config_dir = self.config_dir(trace)
+        options: dict[str, object] = {
+            "strictMcpConfig": True,
+            "disallowedTools": self.config.disabled_tools or [],
+        }
+        session_meta: dict[str, object] = {"claudeCode": {"options": options}}
+        if system_prompt:
+            session_meta["systemPrompt"] = {"append": system_prompt}
+        env = {
+            **self.config.resolved_env,
+            "ANTHROPIC_BASE_URL": endpoint.removesuffix("/v1"),
+            "ANTHROPIC_API_KEY": secret,
+            "ANTHROPIC_MODEL": ctx.model,
+            "CLAUDE_CONFIG_DIR": config_dir,
+            "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
+            "DISABLE_AUTOUPDATER": "1",
+            "IS_SANDBOX": "1",
+        }
+        return CLAUDE_ACP.session(
+            self,
+            ctx,
+            trace,
+            runtime,
+            endpoint,
+            secret,
+            mcp_urls,
+            data,
+            env=env,
+            command=ACP_COMMAND,
+            prompt=prompt or "",
+            session_meta=session_meta,
         )
-        result = await runtime.run(["sh", "-c", guarded], self.config.resolved_env)
-        if result.exit_code != 0:
-            detail = (result.stderr or result.stdout).strip()[-500:]
-            raise RuntimeError(f"Claude Code install failed: {detail}")
 
     async def launch(
         self,
@@ -62,44 +122,44 @@ class ClaudeCodeHarness(Harness[ClaudeCodeHarnessConfig]):
         mcp_urls: dict[str, str],
         data: TaskData,
     ) -> ProgramResult:
-        system_prompt, instruction = self.resolve_text_prompt(data)
+        system_prompt, prompt = self.resolve_prompt(data)
+        config_dir = self.config_dir(trace)
+
+        options: dict[str, object] = {
+            "strictMcpConfig": True,
+            "disallowedTools": self.config.disabled_tools or [],
+        }
+        session_meta: dict[str, object] = {"claudeCode": {"options": options}}
+        if system_prompt:
+            session_meta["systemPrompt"] = {"append": system_prompt}
         env = {
             **self.config.resolved_env,
             # Claude appends /v1/messages; give it the interception root, not the model endpoint.
             "ANTHROPIC_BASE_URL": endpoint.removesuffix("/v1"),
             "ANTHROPIC_API_KEY": secret,
-            "CLAUDE_CONFIG_DIR": CLAUDE_CONFIG_DIR,
+            "ANTHROPIC_MODEL": ctx.model,
+            "CLAUDE_CONFIG_DIR": config_dir,
             "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
             "DISABLE_AUTOUPDATER": "1",
             "IS_SANDBOX": "1",
         }
-        argv = [
-            CLAUDE_BIN.format(version=self.config.version),
-            "--print",
-            "--dangerously-skip-permissions",
-            "--no-session-persistence",
-            "--model",
-            ctx.model,
-        ]
-        if system_prompt:
-            argv += ["--append-system-prompt", system_prompt]
-        argv += [
-            arg
-            for tool in self.config.disabled_tools or []
-            for arg in ("--disallowedTools", tool)
-        ]
-        mcp = {
-            "mcpServers": {
-                name: {"type": "http", "url": url} for name, url in mcp_urls.items()
-            }
-        }
-        mcp_path = f"{CLAUDE_CONFIG_DIR}/mcp.json"
-        await runtime.write(mcp_path, json.dumps(mcp).encode())
-        argv += [
-            "--mcp-config",
-            mcp_path,
-            "--strict-mcp-config",
-            "--",
-            instruction or "",
-        ]
-        return await runtime.run_program(argv, env)
+        return await CLAUDE_ACP.run(
+            runtime,
+            env,
+            ACP_COMMAND,
+            prompt or "",
+            mcp_urls=mcp_urls,
+            session_path=f"{config_dir}/acp-session",
+            session_meta=session_meta,
+        )
+
+    async def cleanup(self, trace: Trace, runtime: Runtime) -> None:
+        result = await runtime.run(["rm", "-rf", self.config_dir(trace)], {})
+        if result.exit_code != 0:
+            raise RuntimeError(
+                f"failed to clean up Claude config: {result.stderr.strip()[-500:]}"
+            )
+
+    @staticmethod
+    def config_dir(trace: Trace) -> str:
+        return f"{CLAUDE_CONFIG_ROOT}/{trace.id}"

verifiers/v1/harnesses/codex/harness.py

@@ -1,9 +1,5 @@
-"""Codex reaches interception as a Responses API provider using the session secret.
+"""Run Codex through its App Server-backed ACP adapter."""
 
-The static musl binary runs in Linux containers without additional runtime dependencies.
-"""
-
-import base64
 import hashlib
 import json
 import logging
@@ -11,39 +7,47 @@ import re
 import shlex
 from collections import Counter
 
+from verifiers.v1.acp import ACP
 from verifiers.v1.clients import ModelContext
 from verifiers.v1.configs.harness import HarnessConfig
-from verifiers.v1.harness import Harness
+from verifiers.v1.harness import Harness, HarnessSession
+from verifiers.v1.harnesses.node import NODE_BIN_DIR, ensure_node
 from verifiers.v1.runtimes import ProgramResult, Runtime
 from verifiers.v1.task import TaskData
 from verifiers.v1.trace import Trace
-from verifiers.v1.types import TextContentPart
 
 logger = logging.getLogger(__name__)
 
-# The provider id we register on the fly via `-c` overrides — arbitrary, internal to codex.
 PROVIDER = "intercept"
-# The env var codex reads the provider api key (its bearer = the session secret) from.
 KEY_VAR = "CODEX_INTERCEPT_KEY"
 
-CODEX_DIR = "/tmp/vf-codex"
-CODEX_BIN = f"{CODEX_DIR}/bin/codex"
+CODEX_DIR = "/var/tmp/vf-codex"
+PACKAGES_DIR = f"{CODEX_DIR}/acp"
+CODEX_VERSION = "0.145.0"
+ACP_VERSION = "1.1.7"
+ACP_BIN = f"{PACKAGES_DIR}/node_modules/.bin/codex-acp"
+ACP_COMMAND = [f"{NODE_BIN_DIR}/node", ACP_BIN]
 SKILLS_DIR = ".agents/skills"
 INSTALL = r"""
 set -e
-mkdir -p {dir}/bin
-command -v curl >/dev/null 2>&1 || { apt-get update -qq && apt-get install -y -qq curl >/dev/null; }
-case "$(uname -m)" in aarch64|arm64) arch=aarch64 ;; *) arch=x86_64 ;; esac
-triple="${arch}-unknown-linux-musl"
-curl -fsSL "https://github.com/openai/codex/releases/download/rust-v{version}/codex-${triple}.tar.gz" | tar -xz -C {dir}/bin
-mv "{dir}/bin/codex-${triple}" {bin}
-chmod +x {bin}
+export PATH="/var/tmp/vf-node/bin:$PATH"
+versions="$VF_CODEX_VERSION:$VF_CODEX_ACP_VERSION"
+if [ "$(cat /var/tmp/vf-codex/.versions 2>/dev/null)" = "$versions" ] \
+    && [ -x /var/tmp/vf-codex/acp/node_modules/.bin/codex ] \
+    && [ -x /var/tmp/vf-codex/acp/node_modules/.bin/codex-acp ]; then
+    exit 0
+fi
+npm install --prefix /var/tmp/vf-codex/acp --ignore-scripts --no-audit --no-fund \
+    --omit=dev \
+    "@agentclientprotocol/codex-acp@$VF_CODEX_ACP_VERSION" \
+    "@openai/codex@$VF_CODEX_VERSION" >/dev/null
+printf %s "$versions" > /var/tmp/vf-codex/.versions
 """
 
+CODEX_ACP = ACP()
+
 
 class CodexHarnessConfig(HarnessConfig):
-    version: str = "0.144.5"
-    """Codex release to install (the `rust-v<version>` GitHub release); pinned for reproducibility."""
     multi_agent: bool = False
     """Enable Codex's native multi-agent v2 tools."""
 
@@ -56,22 +60,30 @@ class CodexHarness(Harness[CodexHarnessConfig]):
 
     async def setup(self, runtime: Runtime) -> None:
         await self.install_skills(runtime, SKILLS_DIR)
-        logger.info("codex: ensuring codex %s is installed", self.config.version)
-        script = (
-            INSTALL.replace("{version}", self.config.version)
-            .replace("{dir}", CODEX_DIR)
-            .replace("{bin}", CODEX_BIN)
+        await ensure_node(runtime)
+        logger.info(
+            "codex: ensuring Codex %s and codex-acp %s are installed",
+            CODEX_VERSION,
+            ACP_VERSION,
         )
-        ensure = shlex.quote(f"[ -x {CODEX_BIN} ] || ({script})")
-        # Shared local runtimes may provision concurrently; only the first downloads.
         guarded = (
-            f"mkdir -p {CODEX_DIR} && flock {CODEX_DIR}/install.lock sh -c {ensure}"
+            f"mkdir -p {CODEX_DIR} && "
+            f'"$(command -v flock || command -v lockf)" {CODEX_DIR}/install.lock '
+            f"sh -c {shlex.quote(INSTALL)}"
+        )
+        install = await runtime.run(
+            ["sh", "-c", guarded],
+            {
+                **self.config.resolved_env,
+                "VF_CODEX_VERSION": CODEX_VERSION,
+                "VF_CODEX_ACP_VERSION": ACP_VERSION,
+            },
         )
-        install = await runtime.run(["sh", "-c", guarded], {})
         if install.exit_code != 0:
             raise RuntimeError(f"codex install failed: {install.stderr.strip()[-500:]}")
+        await CODEX_ACP.setup(self, runtime)
 
-    async def launch(
+    async def session(
         self,
         ctx: ModelContext,
         trace: Trace,
@@ -80,77 +92,32 @@ class CodexHarness(Harness[CodexHarnessConfig]):
         secret: str,
         mcp_urls: dict[str, str],
         data: TaskData,
-    ) -> ProgramResult:
-        task = data
-        if (
-            task.system_prompt is not None
-            and task.prompt is not None
-            and not isinstance(task.prompt, str)
-        ):
-            system_prompt, prompt = task.system_prompt, task.prompt
-        else:
-            system_prompt, prompt = self.resolve_prompt(task)
-        image_args: list[str] = []
-        image_dir = f".vf-codex-images-{trace.id}"
-        if prompt is not None and not isinstance(prompt, str):
-            # Codex seeds one initial turn, so Messages system text joins its prompt.
-            texts = [system_prompt] if system_prompt else []
-            image_index = 0
-            for message in prompt:
-                if message.role not in ("system", "user"):
-                    raise ValueError(
-                        "codex exec only supports system and user initial messages"
-                    )
-                parts = (
-                    [TextContentPart(text=message.content)]
-                    if isinstance(message.content, str)
-                    else message.content
-                )
-                for part in parts:
-                    if isinstance(part, TextContentPart):
-                        texts.append(part.text)
-                        continue
-                    metadata, separator, encoded = part.image_url.url.partition(",")
-                    media_type, *parameters = metadata.removeprefix("data:").split(";")
-                    if (
-                        not separator
-                        or not metadata.startswith("data:image/")
-                        or not any(p.lower() == "base64" for p in parameters)
-                    ):
-                        raise ValueError(
-                            "codex image prompts require base64 data:image URLs"
-                        )
-                    extension = re.sub(
-                        r"[^a-zA-Z0-9]+", "_", media_type.removeprefix("image/")
-                    ).strip("_")
-                    path = f"{image_dir}/image_{image_index}.{extension or 'image'}"
-                    await runtime.write(path, base64.b64decode(encoded))
-                    image_args += ["-i", path]
-                    image_index += 1
-            prompt = "\n\n".join(texts)
-        argv = [
-            CODEX_BIN,
-            "exec",
-            *self._config_args(ctx, endpoint, mcp_urls),
-            *image_args,
-            "--",
-            prompt,
-        ]
-        try:
-            return await runtime.run_program(
-                argv, await self._env(trace, runtime, secret)
+    ) -> HarnessSession:
+        if not runtime.supports_live_processes:
+            return await super().session(
+                ctx, trace, runtime, endpoint, secret, mcp_urls, data
             )
-        finally:
-            if image_args:
-                try:
-                    await runtime.run(["rm", "-rf", image_dir], {})
-                except Exception:
-                    # Runtime teardown is the fallback; preserve the rollout result.
-                    logger.warning(
-                        "failed to clean up Codex prompt images", exc_info=True
-                    )
+        if data.system_prompt is not None and not isinstance(data.prompt, str):
+            system_prompt, prompt = data.system_prompt, data.prompt
+        else:
+            system_prompt, prompt = self.resolve_prompt(data)
+        env = await self.build_env(ctx, trace, runtime, endpoint, secret, mcp_urls)
+        return CODEX_ACP.session(
+            self,
+            ctx,
+            trace,
+            runtime,
+            endpoint,
+            secret,
+            {},
+            data,
+            env=env,
+            command=ACP_COMMAND,
+            prompt=prompt,
+            system_prompt=system_prompt,
+        )
 
-    async def resume(
+    async def launch(
         self,
         ctx: ModelContext,
         trace: Trace,
@@ -159,120 +126,71 @@ class CodexHarness(Harness[CodexHarnessConfig]):
         secret: str,
         mcp_urls: dict[str, str],
         data: TaskData,
-        messages,
     ) -> ProgramResult:
-        """Native continuation: `codex exec resume --last` re-opens the session the
-        previous segment recorded — codex's own context, compaction included — and
-        takes the user's next turn. Nothing is replayed into its prompt (replaying
-        our view of the conversation would fight codex's own session state, which is
-        exactly why the default relaunch-resume is wrong for it). The rollout's
-        per-trace `CODEX_HOME` (see `_env`) makes `--last` unambiguous even when a
-        borrowed runtime hosts several rollouts."""
-        texts: list[str] = []
-        for message in messages:
-            if message.role != "user":
-                raise ValueError("codex resume takes user turns only")
-            parts = (
-                [TextContentPart(text=message.content)]
-                if isinstance(message.content, str)
-                else message.content
-            )
-            for part in parts:
-                if not isinstance(part, TextContentPart):
-                    raise TypeError(
-                        "codex resume supports text user turns only (images go in "
-                        "the opening prompt)"
-                    )
-                texts.append(part.text)
-        if trace.num_turns == 0:
-            return await self.launch(
-                ctx,
-                trace,
-                runtime,
-                endpoint,
-                secret,
-                mcp_urls,
-                data.model_copy(update={"prompt": messages}),
-            )
-        argv = [
-            CODEX_BIN,
-            "exec",
-            "resume",
-            "--last",
-            *self._config_args(ctx, endpoint, mcp_urls),
-            "--",
-            "\n\n".join(texts),
-        ]
-        return await runtime.run_program(argv, await self._env(trace, runtime, secret))
+        if (
+            data.system_prompt is not None
+            and data.prompt is not None
+            and not isinstance(data.prompt, str)
+        ):
+            system_prompt, prompt = data.system_prompt, data.prompt
+        else:
+            system_prompt, prompt = self.resolve_prompt(data)
+        env = await self.build_env(ctx, trace, runtime, endpoint, secret, mcp_urls)
+        return await CODEX_ACP.run(
+            runtime,
+            env,
+            ACP_COMMAND,
+            prompt,
+            system_prompt=system_prompt,
+            session_path=f"{self.trace_home(trace)}/acp-session",
+        )
 
     async def cleanup(self, trace: Trace, runtime: Runtime) -> None:
-        home = self._home(trace)
-        result = await runtime.run(["rm", "-rf", home], {})
+        result = await runtime.run(["rm", "-rf", self.trace_home(trace)], {})
         if result.exit_code != 0:
             raise RuntimeError(
                 f"failed to clean up Codex home: {result.stderr.strip()[-500:]}"
             )
 
     @staticmethod
-    def _home(trace: Trace) -> str:
+    def trace_home(trace: Trace) -> str:
         return f"/tmp/vf-codex-home-{trace.id}"
 
-    async def _env(self, trace: Trace, runtime: Runtime, secret: str) -> dict[str, str]:
-        # codex authenticates to the interception server with the session secret (its
-        # provider api key) and posts Responses calls to `{endpoint}/responses`. The
-        # per-trace CODEX_HOME scopes its recorded sessions to this rollout, so
-        # `exec resume --last` continues THIS exchange and never a neighbor's.
-        # codex refuses a home that doesn't exist, so make it before every segment.
-        home = self._home(trace)
-        await runtime.run(["mkdir", "-p", home], {})
-        return {
-            **self.config.resolved_env,
-            KEY_VAR: secret,
-            "CODEX_HOME": home,
-        }
-
-    def _config_args(
+    async def build_env(
         self,
         ctx: ModelContext,
+        trace: Trace,
+        runtime: Runtime,
         endpoint: str,
+        secret: str,
         mcp_urls: dict[str, str],
-    ) -> list[str]:
-        # Values are Codex feature names such as `shell_tool`; Codex owns validation.
-        # https://developers.openai.com/codex/config-reference#features
-        tool_config = [
-            arg
-            for tool in self.config.disabled_tools or []
-            for arg in ("--disable", tool)
-        ]
-        # Set the whole table so dots in quoted server IDs are not interpreted as
-        # `-c` path separators.
+    ) -> dict[str, str]:
+        home = self.trace_home(trace)
+        created = await runtime.run(["mkdir", "-p", home], {})
+        if created.exit_code != 0:
+            raise RuntimeError(
+                f"failed to create Codex home: {created.stderr.strip()[-500:]}"
+            )
+
         mcp_config = (
-            [
-                "-c",
-                "mcp_servers={"
-                + ",".join(
-                    (
-                        f"{json.dumps(name, ensure_ascii=False)}="
-                        f"{{url={json.dumps(url, ensure_ascii=False)},required=true,"
-                        f"startup_timeout_sec=60.0,tool_timeout_sec={self.config.tool_timeout}}}"
-                    )
-                    for name, url in mcp_urls.items()
-                )
-                + "}",
-            ]
+            "mcp_servers={"
+            + ",".join(
+                f"{json.dumps(name, ensure_ascii=False)}="
+                f"{{url={json.dumps(url, ensure_ascii=False)},required=true,"
+                f"startup_timeout_sec=60.0,tool_timeout_sec={self.config.tool_timeout}}}"
+                for name, url in mcp_urls.items()
+            )
+            + "}"
             if mcp_urls
-            else []
+            else ""
         )
+        await runtime.write(f"{home}/config.toml", mcp_config.encode())
 
-        # Codex keeps raw server IDs for MCP calls but normalizes the namespaces
-        # exposed to the model. Mirror rust-v0.144.5's per-character replacement,
-        # optional prefix, collision hash, and possible 49-character truncation.
-        namespace_bases: dict[str, str] = {}
-        for name in mcp_urls:
-            namespace = re.sub(r"[^a-zA-Z0-9_]", "_", name) or "_"
-            namespace_bases[name] = (
-                namespace if namespace.startswith("mcp__") else f"mcp__{namespace}"
-            )
+        namespace_bases = {
+            name: (namespace if namespace.startswith("mcp__") else f"mcp__{namespace}")
+            for name in mcp_urls
+            for namespace in (re.sub(r"[^a-zA-Z0-9_]", "_", name) or "_",)
+        }
         namespace_counts = Counter(namespace_bases.values())
         direct_mcp_namespaces: list[str] = []
         for name, namespace in namespace_bases.items():
@@ -286,47 +204,43 @@ class CodexHarness(Harness[CodexHarnessConfig]):
             direct_mcp_namespaces.append(namespace)
             if len(namespace) > 49:
                 direct_mcp_namespaces.append(namespace[:49])
-        direct_mcp_namespaces = list(dict.fromkeys(direct_mcp_namespaces))
-        # `-c` values parse as TOML, falling back to a raw string (so the url / `responses`
-        # come through literally); `requires_openai_auth=false` parses as a bool.
-        return [
-            "--dangerously-bypass-approvals-and-sandbox",
-            "--skip-git-repo-check",
-            # Apps/plugins can flip on remotely and advertise definitions custom providers reject.
-            "--disable",
-            "apps",
-            "--disable",
-            "plugins",
-            "--disable",
-            "multi_agent",
-            # Preserve any user-supplied multi-agent v2 tool and limit settings.
-            "-c",
-            f"features.multi_agent_v2.enabled={str(self.config.multi_agent).lower()}",
-            "-m",
-            ctx.model,
-            "-c",
-            f"model_provider={PROVIDER}",
-            "-c",
-            f"model_providers.{PROVIDER}.name={PROVIDER}",
-            "-c",
-            f"model_providers.{PROVIDER}.base_url={endpoint}",
-            "-c",
-            f"model_providers.{PROVIDER}.env_key={KEY_VAR}",
-            "-c",
-            f"model_providers.{PROVIDER}.wire_api=responses",
-            "-c",
-            f"model_providers.{PROVIDER}.requires_openai_auth=false",
-            *tool_config,
-            *mcp_config,
-            *(
-                [
-                    "-c",
-                    (
-                        "features.code_mode.direct_only_tool_namespaces="
-                        f"{json.dumps(direct_mcp_namespaces)}"
-                    ),
-                ]
-                if direct_mcp_namespaces
-                else []
-            ),
-        ]
+
+        features: dict[str, object] = {
+            "apps": False,
+            "plugins": False,
+            "multi_agent": False,
+            "multi_agent_v2": {"enabled": self.config.multi_agent},
+            **{tool: False for tool in self.config.disabled_tools or []},
+        }
+        if direct_mcp_namespaces:
+            features["code_mode"] = {
+                "direct_only_tool_namespaces": list(
+                    dict.fromkeys(direct_mcp_namespaces)
+                )
+            }
+        config = {
+            "model": ctx.model,
+            "model_provider": PROVIDER,
+            "model_providers": {
+                PROVIDER: {
+                    "name": PROVIDER,
+                    "base_url": endpoint,
+                    "env_key": KEY_VAR,
+                    "wire_api": "responses",
+                    "requires_openai_auth": False,
+                }
+            },
+            "features": features,
+        }
+        return {
+            **self.config.resolved_env,
+            "CODEX_API_KEY": secret,
+            KEY_VAR: secret,
+            "APP_SERVER_LOGS": f"{home}/logs",
+            "CODEX_CONFIG": json.dumps(config),
+            "CODEX_HOME": home,
+            "DEFAULT_AUTH_REQUEST": json.dumps({"methodId": "api-key"}),
+            "INITIAL_AGENT_MODE": "agent-full-access",
+            "MODEL_PROVIDER": PROVIDER,
+            "NO_BROWSER": "1",
+        }

verifiers/v1/harnesses/node.py

@@ -0,0 +1,54 @@
+import shlex
+
+from verifiers.v1.runtimes import Runtime
+
+NODE_DIR = "/var/tmp/vf-node"
+NODE_BIN_DIR = f"{NODE_DIR}/bin"
+NODE_VERSION = "22.19.0"
+
+INSTALL = r"""
+set -e
+node=/var/tmp/vf-node
+node_ok() { "$node/bin/node" -e 'const [a,b]=process.versions.node.split(".").map(Number); process.exit(a>22 || a===22 && b>=19 ? 0 : 1)'; }
+
+if [ -f /etc/alpine-release ]; then
+    apk add --no-cache curl ca-certificates nodejs-current npm >/dev/null
+    if ! node -e 'const [a,b]=process.versions.node.split(".").map(Number); process.exit(a>22 || a===22 && b>=19 ? 0 : 1)'; then
+        sed -E -i 's/v[0-9]+\.[0-9]+/v3.22/g' /etc/apk/repositories
+        apk upgrade --available --no-cache >/dev/null
+        apk add --no-cache nodejs-current npm >/dev/null
+    fi
+    mkdir -p "$node/bin"
+    ln -sf "$(command -v node)" "$node/bin/node"
+    ln -sf "$(command -v npm)" "$node/bin/npm"
+else
+    command -v curl >/dev/null 2>&1 \
+        || { apt-get update -qq && apt-get install -y -qq curl ca-certificates >/dev/null; }
+    case "$(uname -s)" in Linux) node_os=linux ;; Darwin) node_os=darwin ;; *) echo "unsupported os: $(uname -s)" >&2; exit 1 ;; esac
+    if [ ! -x "$node/bin/node" ] || [ "$("$node/bin/node" --version 2>/dev/null)" != "v$VF_NODE_VERSION" ]; then
+        case "$(uname -m)" in aarch64|arm64) node_arch=arm64 ;; *) node_arch=x64 ;; esac
+        rm -rf "$node"
+        mkdir -p "$node"
+        curl -fsSL "https://nodejs.org/dist/v$VF_NODE_VERSION/node-v$VF_NODE_VERSION-${node_os}-${node_arch}.tar.gz" \
+            | tar -xz -C "$node" --strip-components=1
+    fi
+fi
+node_ok || { echo "ACP adapters require Node.js 22.19 or newer" >&2; exit 1; }
+"""
+
+
+async def ensure_node(runtime: Runtime) -> None:
+    """Install the shared Node runtime used by ACP adapter harnesses."""
+    lock = f"{NODE_DIR}.install.lock"
+    guarded = (
+        f'until ln -s "$$" {lock} 2>/dev/null; do '
+        f"owner=$(readlink {lock}); "
+        f'if ! kill -0 "$owner" 2>/dev/null; then '
+        f'[ "$(readlink {lock})" != "$owner" ] || rm -f {lock}; fi; '
+        f"sleep 0.1; done; "
+        f'trap \'[ "$(readlink {lock})" != "$$" ] || rm -f {lock}\' EXIT; '
+        f"sh -c {shlex.quote(INSTALL)}"
+    )
+    result = await runtime.run(["sh", "-c", guarded], {"VF_NODE_VERSION": NODE_VERSION})
+    if result.exit_code != 0:
+        raise RuntimeError(f"Node.js install failed: {result.stderr.strip()[-500:]}")

verifiers/v1/harnesses/pi/harness.py

@@ -8,6 +8,7 @@ from verifiers.v1.acp import ACP
 from verifiers.v1.clients import ModelContext
 from verifiers.v1.configs.harness import HarnessConfig
 from verifiers.v1.harness import Harness
+from verifiers.v1.harnesses.node import NODE_BIN_DIR, ensure_node
 from verifiers.v1.runtimes import ProgramResult, Runtime
 from verifiers.v1.task import TaskData
 from verifiers.v1.trace import Trace
@@ -18,13 +19,12 @@ PROVIDER = "intercept"
 KEY_VAR = "PI_INTERCEPT_KEY"
 HOME_VAR = "VF_PI_ORIGINAL_HOME"
 
-PI_DIR = "/tmp/vf-pi"
+PI_DIR = "/var/tmp/vf-pi"
 PACKAGES_DIR = f"{PI_DIR}/mcp"
 PI_BIN = f"{PACKAGES_DIR}/node_modules/.bin/pi"
 SKILLS_DIR = ".agents/skills"
 MCP_VERSION = "2.11.0"
 ACP_VERSION = "0.0.31"
-NODE_VERSION = "22.19.0"
 MCP_ADAPTER = f"{PACKAGES_DIR}/node_modules/pi-mcp-adapter/index.ts"
 ACP_BIN = f"{PACKAGES_DIR}/node_modules/.bin/pi-acp"
 ACP_COMMAND = [
@@ -34,39 +34,14 @@ ACP_COMMAND = [
         f'export {HOME_VAR}="$HOME"; '
         'PI_CODING_AGENT_DIR="$PWD/$PI_CODING_AGENT_DIR"; '
         'export PI_CODING_AGENT_DIR HOME="$PI_CODING_AGENT_DIR"; '
-        f'export PATH="{PI_DIR}/node/bin:$PATH"; exec {ACP_BIN}'
+        f'export PATH="{NODE_BIN_DIR}:$PATH"; exec {ACP_BIN}'
     ),
 ]
 
 INSTALL = r"""
 set -e
-packages=/tmp/vf-pi/mcp
-node=/tmp/vf-pi/node
-node_ok() { node -e 'const [a,b]=process.versions.node.split(".").map(Number); process.exit(a>22 || a===22 && b>=19 ? 0 : 1)'; }
-
-if [ -f /etc/alpine-release ]; then
-    apk add --no-cache curl ca-certificates nodejs-current npm >/dev/null
-    if ! node_ok; then
-        sed -E -i 's/v[0-9]+\.[0-9]+/v3.22/g' /etc/apk/repositories
-        apk upgrade --available --no-cache >/dev/null
-        apk add --no-cache nodejs-current npm >/dev/null
-    fi
-    node_bin="$(dirname "$(command -v node)")"
-else
-    command -v curl >/dev/null 2>&1 \
-        || { apt-get update -qq && apt-get install -y -qq curl ca-certificates >/dev/null; }
-    case "$(uname -s)" in Linux) node_os=linux ;; Darwin) node_os=darwin ;; *) echo "unsupported os: $(uname -s)" >&2; exit 1 ;; esac
-    if [ ! -x "$node/bin/node" ] || [ "$("$node/bin/node" --version 2>/dev/null)" != "v$VF_PI_NODE_VERSION" ]; then
-        case "$(uname -m)" in aarch64|arm64) node_arch=arm64 ;; *) node_arch=x64 ;; esac
-        rm -rf "$node"
-        mkdir -p "$node"
-        curl -fsSL "https://nodejs.org/dist/v$VF_PI_NODE_VERSION/node-v$VF_PI_NODE_VERSION-${node_os}-${node_arch}.tar.gz" \
-            | tar -xz -C "$node" --strip-components=1
-    fi
-    node_bin="$node/bin"
-fi
-export PATH="$node_bin:$PATH"
-node_ok || { echo "pi-acp requires Node.js 22.19 or newer" >&2; exit 1; }
+packages=/var/tmp/vf-pi/mcp
+export PATH="/var/tmp/vf-node/bin:$PATH"
 
 versions="$VF_PI_VERSION:$VF_PI_MCP_VERSION:$VF_PI_ACP_VERSION"
 if [ "$(cat "$packages/.versions" 2>/dev/null)" != "$versions" ]; then
@@ -125,6 +100,7 @@ class PiHarness(Harness[PiHarnessConfig]):
 
     async def setup(self, runtime: Runtime) -> None:
         await self.install_skills(runtime, SKILLS_DIR)
+        await ensure_node(runtime)
         logger.info(
             "pi: ensuring Pi %s and pi-acp %s are installed",
             self.config.version,
@@ -147,7 +123,6 @@ class PiHarness(Harness[PiHarnessConfig]):
                 "VF_PI_VERSION": self.config.version,
                 "VF_PI_MCP_VERSION": MCP_VERSION,
                 "VF_PI_ACP_VERSION": ACP_VERSION,
-                "VF_PI_NODE_VERSION": NODE_VERSION,
             },
         )
         if install.exit_code != 0:

{verifiers-0.2.2.dev89.dist-info → verifiers-0.2.2.dev91.dist-info}/METADATA

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

@@ -183,8 +183,8 @@ verifiers/v1/task.py,sha256=jwMKiKlMtksTd8j2dcDlFtb6LC8BRE-N5jkNXlMp2jc,9457
 verifiers/v1/taskset.py,sha256=fp2E0IEhL_Ybj9cegZwljfTmW27p_30zTWHFKw_kXE4,4374
 verifiers/v1/trace.py,sha256=Mjc9NaqmUVKXhn6RKaTaGVxPRldCGqgHxb74cqtp5_k,20026
 verifiers/v1/types.py,sha256=1PxamJspmoTc3OlFZAwH6o_2i_Tg9ZNvHxttIHWIxq8,8948
-verifiers/v1/acp/__init__.py,sha256=yy0IHXEF6Ydc62PtlKVSz_5JybYRRcTV6cYPNA-JwAI,11294
-verifiers/v1/acp/runner.py,sha256=ruFBLYnVzXxF-uIShULP3SCl-VKA7q3HFQGPS1agrdQ,14205
+verifiers/v1/acp/__init__.py,sha256=RusAr7bFDHOjQc3mgqnADfhgen9bJlyLs8wQke2fUUs,11675
+verifiers/v1/acp/runner.py,sha256=4VWM-KWS7jD2tuU_CxO4wwnYNrii6hTDawX_4q4qoLc,14730
 verifiers/v1/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 verifiers/v1/cli/debug.py,sha256=WGCiapH2CCwyPfESca5623-_csQv93PoglR8yX5-D3g,11488
 verifiers/v1/cli/gepa.py,sha256=hLIbS_4jBx0vvy4PXoePR5riFXcNvzQCMixZ-g2OR_U,4026
@@ -247,6 +247,7 @@ verifiers/v1/gepa/dataset.py,sha256=N2QYqUljHVuAdCbUuydEIlarvAWa6LFdGKu9qsOvjro,
 verifiers/v1/gepa/reflection.py,sha256=ptHhx0lcDLcWhWhXuslh9T8gPVNpnX5XLPtXoneW1yA,1054
 verifiers/v1/gepa/runner.py,sha256=_B_YPd_h3kelbNE2029a6n3-QpqD8HOSDmOJRtX1PR8,6036
 verifiers/v1/harnesses/__init__.py,sha256=cLyHRiH0E63WcVW9dBqR4OEqPSfPR4wQmB6gunghV4Q,1759
+verifiers/v1/harnesses/node.py,sha256=_-7NofTl-TNuwgEg8qxrD28shlQuyBWgiVHwCCwbdVo,2410
 verifiers/v1/harnesses/bash/__init__.py,sha256=IAV4eMMqDHSl-9ANb0Q3kxmBZ22SeHZFBM448X4gQio,140
 verifiers/v1/harnesses/bash/harness.py,sha256=iT-F8fEDaV0jveCOG4ZTavRahhVvbq8ehPTbfG3Cre8,5349
 verifiers/v1/harnesses/bash/program.py,sha256=USO3fu8CyOu_qiUisGTpsFUsu5_56KLwM-JdFZP4k78,15338
@@ -254,9 +255,9 @@ verifiers/v1/harnesses/browser_use/__init__.py,sha256=yxm2IG5TDLadxZEkX8SL26XWbc
 verifiers/v1/harnesses/browser_use/harness.py,sha256=pxlpyJdnIFdlXVeMCcSgMH1uGeuU8LMEG0UF8emLXU0,5900
 verifiers/v1/harnesses/browser_use/program.py,sha256=ygC0e7iocV6bjTyqE4b3QECvQqNsxwFZDBcHOYUUfHY,14291
 verifiers/v1/harnesses/claude_code/__init__.py,sha256=JkZQylMSA3o1fvBx_NM41y_umuahmOSqFjTrJ2hryTw,171
-verifiers/v1/harnesses/claude_code/harness.py,sha256=bZHzTo7xFddJgHf1VrB3ZewzBR-AW0LuoMwxjrpI6Ko,3826
+verifiers/v1/harnesses/claude_code/harness.py,sha256=5eoL5yEQJD9qR9jGf1kuvu5y1E3qE8pRsirVJioOqYQ,5759
 verifiers/v1/harnesses/codex/__init__.py,sha256=ocyBvlpSO8c3pT6D1ebrQohoXYESQcCyPT5kN3j1-N4,132
-verifiers/v1/harnesses/codex/harness.py,sha256=_B5l3zNo02KR7SrEsHchZ5X0eOOjl5cfEnzzp94Lunk,13094
+verifiers/v1/harnesses/codex/harness.py,sha256=OI_B7P6OMbd4E4tR5NtR-iyrs1Sb2OG7XQzx7VXDBNo,8312
 verifiers/v1/harnesses/hermes_agent/__init__.py,sha256=k84Y8UTTf1KOw5LGqPb2dk-hYFagPevDJBOF7qsR_vo,176
 verifiers/v1/harnesses/hermes_agent/harness.py,sha256=AveZi9g4pga9pYy4VAmn_KMKlJw3KhwG45JZcPxbdR4,5094
 verifiers/v1/harnesses/hermes_agent/program.py,sha256=9qPLbUnhox2bGu5ypEEnBhw9QKtYwNvrbl7W_zeNMdk,229
@@ -271,7 +272,7 @@ verifiers/v1/harnesses/null/program.py,sha256=Lapx_g-uioKt0w9r2lcfoIkC0NPAX7wwNz
 verifiers/v1/harnesses/openclaw/__init__.py,sha256=kNyfPB1sGwEf4K3mTfKN0VEyxun3SGvNpvArVKvH-x8,160
 verifiers/v1/harnesses/openclaw/harness.py,sha256=n1o7gvsEEv0OsnU_WvyEd00Q4KizWQawSwHqdvqzLnw,14745
 verifiers/v1/harnesses/pi/__init__.py,sha256=1mSnzOf-RdEchdeg6IHtcdobG5KIpAhuTdUIgsCIn74,117
-verifiers/v1/harnesses/pi/harness.py,sha256=_O-pyg2RM23-RzQosKHKf8uG8KflS4OrWSsEiBCWQpo,8675
+verifiers/v1/harnesses/pi/harness.py,sha256=Gwl-oCMuEplQP4PsrWZarNR3crcVdCbEOJtKCYSWWtc,7387
 verifiers/v1/harnesses/pool/__init__.py,sha256=HTYsNiWGdiNEsSHj4xhPmshJSNb7SHjQ7d4yZQ4p3HM,127
 verifiers/v1/harnesses/pool/harness.py,sha256=6DlOA2W3s-NrxdQ9GaMmZg7mSNJGz2GC21kH2Pmoy9w,4025
 verifiers/v1/harnesses/rlm/__init__.py,sha256=hwx51xTdEWzzYgMj-p4ETNcptoub3IPMDbEdJ4uB8Ns,122
@@ -338,8 +339,8 @@ verifiers/v1/utils/platform.py,sha256=56Ixmk1SER6q5LvzyYcA0hgzGpzhxKZL8Hiqp4c_XV
 verifiers/v1/utils/retries.py,sha256=Y2ZgrAjn-qNkRKZP_RVNL_7EK0iaRcZeCa404lpGYi4,5417
 verifiers/v1/utils/score.py,sha256=-R5Cog14r_tJ6Q_oOfGr5VPAm2CCUhofYZB6B9lm4wM,5787
 verifiers/v1/utils/version.py,sha256=-obEo_-l9-D8FLef4hYxncOe-uJpxrM1g2Hig_37Sgs,1607
-verifiers-0.2.2.dev89.dist-info/METADATA,sha256=qIYFt9H2lhq3l6ahg5qBbTFNgMI6p6vYsMdUQRKvEow,4545
-verifiers-0.2.2.dev89.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-verifiers-0.2.2.dev89.dist-info/entry_points.txt,sha256=v6v0QT9vVExnfn4br42MostI_o3f3ZbWYlTormz-U3g,515
-verifiers-0.2.2.dev89.dist-info/licenses/LICENSE,sha256=v0RrUsdV3IDoZhrRce297IXS3xMHNJ-_LdLpFAUWb9k,1072
-verifiers-0.2.2.dev89.dist-info/RECORD,,
+verifiers-0.2.2.dev91.dist-info/METADATA,sha256=NDm3kLyWtrNXJbEIc2HVEWBarMuI3DrubNo2EhdZAzo,4545
+verifiers-0.2.2.dev91.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+verifiers-0.2.2.dev91.dist-info/entry_points.txt,sha256=v6v0QT9vVExnfn4br42MostI_o3f3ZbWYlTormz-U3g,515
+verifiers-0.2.2.dev91.dist-info/licenses/LICENSE,sha256=v0RrUsdV3IDoZhrRce297IXS3xMHNJ-_LdLpFAUWb9k,1072
+verifiers-0.2.2.dev91.dist-info/RECORD,,