verifiers 0.3.2.dev40__tar.gz → 0.3.2.dev42__tar.gz

{verifiers-0.3.2.dev40 → verifiers-0.3.2.dev42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifiers
-Version: 0.3.2.dev40
+Version: 0.3.2.dev42
 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.dev40 → verifiers-0.3.2.dev42}/verifiers/v1/harnesses/openclaw/harness.py

@@ -20,10 +20,48 @@ logger = logging.getLogger(__name__)
 # OpenClaw and its bundled Node runtime exceed the small /tmp tmpfs in some VMs.
 OPENCLAW_DIR = "/var/tmp/vf-openclaw-{version}"
 OPENCLAW_BIN = f"{OPENCLAW_DIR}/bin/openclaw"
-INSTALL = r"""
+SETUP = r"""
 set -e
-command -v curl >/dev/null || (apt-get update -qq && apt-get install -y -qq curl ca-certificates >/dev/null)
-curl -fsSL --proto '=https' --tlsv1.2 https://openclaw.ai/install-cli.sh | bash -s -- --prefix {dir} --version {version} --no-onboard
+if [ ! -x "$VF_OPENCLAW_BIN" ]; then
+    command -v curl >/dev/null || (apt-get update -qq && apt-get install -y -qq curl ca-certificates >/dev/null)
+    curl -fsSL --proto '=https' --tlsv1.2 https://openclaw.ai/install-cli.sh \
+        | bash -s -- --prefix "$VF_OPENCLAW_DIR" --version "$VF_OPENCLAW_VERSION" --no-onboard
+fi
+set -- $(find "$VF_OPENCLAW_DIR/tools" -type f -path '*/openclaw/dist/session-accessor.sqlite-transcript-store-*.js')
+[ "$#" -eq 1 ] || { echo "could not locate OpenClaw's transcript sanitizer for replay patch" >&2; exit 1; }
+"$VF_OPENCLAW_DIR/tools/node/bin/node" - "$1" <<'NODE'
+const fs = require("node:fs");
+const file = process.argv[2];
+const stat = fs.statSync(file);
+if (stat.size > 1_000_000) {
+    throw new Error("OpenClaw's transcript sanitizer exceeds the replay patch size limit");
+}
+const source = fs.readFileSync(file, "utf8");
+const patches = [
+    [
+        "const OPAQUE_REPLAY_TOKEN_RE = /^[A-Za-z0-9+/_-]+={0,2}$/;",
+        "const OPAQUE_REPLAY_TOKEN_RE = /^[A-Za-z0-9+/_-]+={0,2}(?:[.][A-Za-z0-9+/_-]+={0,2})*$/;",
+    ],
+    ["\t\tsummary: [],", "\t\tsummary: parsed.summary ?? [],"],
+];
+let patched = source;
+for (const [before, after] of patches) {
+    patched = patched.replaceAll(before, after);
+}
+if (!patches.every(([, after]) => patched.includes(after))) {
+    throw new Error("OpenClaw's transcript sanitizer does not match the replay patch");
+}
+if (patched !== source) {
+    const temporary = `${file}.${process.pid}.tmp`;
+    try {
+        // Publish complete bytes at once so live and concurrent setups never see a partial bundle.
+        fs.writeFileSync(temporary, patched, { mode: stat.mode });
+        fs.renameSync(temporary, file);
+    } finally {
+        fs.rmSync(temporary, { force: true });
+    }
+}
+NODE
 """
 
 OPENCLAW_COMMAND = [
@@ -82,7 +120,7 @@ wait "$acp_pid"
 
 
 class OpenClawHarnessConfig(HarnessConfig):
-    version: str = Field(default="2026.7.1-2", pattern=r"^[A-Za-z0-9._+-]+$")
+    version: str = Field(default="2026.8.1", pattern=r"^[A-Za-z0-9._+-]+$")
     """OpenClaw release to install, pinned for reproducibility."""
     use_bundled_skill: bool = True
     """Enable OpenClaw's bundled skill catalog in addition to uploaded harness skills."""
@@ -117,20 +155,27 @@ class OpenClawHarness(ACPHarness[OpenClawHarnessConfig]):
                     await runtime.write(ready_path, b"")
         directory = OPENCLAW_DIR.format(version=self.config.version)
         binary = OPENCLAW_BIN.format(version=self.config.version)
-        script = INSTALL.replace("{version}", self.config.version).replace(
-            "{dir}", directory
-        )
-        ensure = shlex.quote(f"[ -x {binary} ] || ({script})")
+        # Borrowed runtimes can share this cache, so one filesystem lock owns both
+        # installation and the transcript adjustment.
         guarded = (
-            f"mkdir -p {directory} && "
-            f'"$(command -v flock || command -v lockf)" {directory}/install.lock '
-            f"bash -o pipefail -c {ensure}"
+            f"mkdir -p {shlex.quote(directory)} && "
+            f'"$(command -v flock || command -v lockf)" '
+            f"{shlex.quote(f'{directory}/install.lock')} "
+            f"bash -o pipefail -c {shlex.quote(SETUP)}"
         )
         logger.info("openclaw: ensuring OpenClaw %s is installed", self.config.version)
-        result = await runtime.run(["sh", "-c", guarded], self.config.resolved_env)
+        result = await runtime.run(
+            ["sh", "-c", guarded],
+            {
+                **self.config.resolved_env,
+                "VF_OPENCLAW_BIN": binary,
+                "VF_OPENCLAW_DIR": directory,
+                "VF_OPENCLAW_VERSION": self.config.version,
+            },
+        )
         if result.exit_code != 0:
             detail = (result.stderr or result.stdout).strip()[-500:]
-            raise RuntimeError(f"OpenClaw install failed: {detail}")
+            raise RuntimeError(f"OpenClaw setup failed: {detail}")
         await super().setup(runtime)
 
     async def prepare_acp(
@@ -149,8 +194,6 @@ class OpenClawHarness(ACPHarness[OpenClawHarnessConfig]):
         config_path = f"{state_dir}/openclaw.json"
         skills_dir = f"{state_dir}/skills"
         config = {
-            # Provider state must remain byte-exact within this isolated rollout.
-            "logging": {"redactSensitive": "off"},
             "gateway": {
                 "mode": "local",
                 "bind": "loopback",
@@ -180,6 +223,7 @@ class OpenClawHarness(ACPHarness[OpenClawHarnessConfig]):
                     provider: {
                         "baseUrl": endpoint,
                         "apiKey": "${OPENCLAW_INTERCEPT_KEY}",
+                        "request": {"allowPrivateNetwork": True},
                     }
                 },
             },

{verifiers-0.3.2.dev40 → verifiers-0.3.2.dev42}/verifiers/v1/harnesses/rlm/harness.py

@@ -68,8 +68,8 @@ class RLMHarnessConfig(HarnessConfig):
     unset defers to nano-rlm's default (on, automatic thresholds, bounded by its
     default 1M tree-token budget)."""
     max_concurrent_subagents: PositiveInt | None = None
-    """Sub-agents running at once per session tree; `None` = nano-rlm's default (4).
-    nano-rlm requires it to be at least `max_depth`."""
+    """Sub-agents running at once per session tree; `None` = nano-rlm's default (4),
+    raised to an explicit `max_depth` when needed to keep the policy valid."""
     max_total_turns: PositiveInt | None = None
     """Tree-total turn budget (one turn = one work-loop model call, any engine); every
     engine stops before its next call once spent. `None` = uncapped."""
@@ -152,9 +152,12 @@ class RLMHarness(ACPHarness[RLMHarnessConfig]):
         system_prompt: str | None,
     ) -> JsonObject:
         compaction = self.config.compaction
+        max_concurrent_subagents = self.config.max_concurrent_subagents
+        if max_concurrent_subagents is None and self.config.max_depth is not None:
+            max_concurrent_subagents = max(4, self.config.max_depth)
         policy_knobs: dict[str, Any] = {
             "max_depth": self.config.max_depth,
-            "max_concurrent_subagents": self.config.max_concurrent_subagents,
+            "max_concurrent_subagents": max_concurrent_subagents,
             "max_total_turns": self.config.max_total_turns,
             "max_total_tokens": self.config.max_total_tokens,
             "max_tool_output_bytes": self.config.max_tool_output_bytes,