| """Opt-in, one-per-episode recovery for a no-tool output-length cutoff. |
| |
| This is a local Bash-loop extension, inspired by mini-SWE-agent's upstream |
| format feedback. Native Prime interception retains both model generations. |
| """ |
| import ast |
| import hashlib |
| import importlib.metadata |
| import importlib.util |
| import py_compile |
| from pathlib import Path |
|
|
| ENVIRONMENT_VARIABLE = "VF_BASH_LENGTH_RECOVERY" |
| RECOVERY_MESSAGE = ( |
| "Your response reached the output limit before issuing a tool call. " |
| "Keep your reasoning brief and take the next concrete action using a tool." |
| ) |
| ORIGINAL_LOOP_SHA256 = "c700239176c6731643eaa3fcb624366b473dddd8f1c5bc98540f1c11173354dd" |
| _INITIALIZE = ''' import os |
| import sys |
| |
| recovery_setting = os.environ.get("VF_BASH_LENGTH_RECOVERY", "0") |
| if recovery_setting not in ("0", "1"): |
| raise ValueError("VF_BASH_LENGTH_RECOVERY must be 0 or 1") |
| recovery_used = False |
| ''' |
| _ORIGINAL_REPLY = ''' message = completion.choices[0].message |
| messages.append(message.model_dump(exclude_none=True)) |
| ''' |
| _RECOVERY_REPLY = f''' message = completion.choices[0].message |
| if ( |
| recovery_setting == "1" |
| and not recovery_used |
| and completion.choices[0].finish_reason == "length" |
| and not message.tool_calls |
| ): |
| recovery_used = True |
| # The interceptor has already recorded this completion. Do not send |
| # the unfinished assistant response back as conversation history. |
| # Prime's native graph records the resulting alternate branch. |
| messages.append({{"role": "user", "content": {RECOVERY_MESSAGE!r}}}) |
| print( |
| "VF_BASH_LENGTH_RECOVERY " + json.dumps({{ |
| "event": "corrective_request", "budget_per_episode": 1, |
| "finish_reason": "length", "tool_calls": 0, |
| }}), file=sys.stderr, flush=True, |
| ) |
| continue |
| messages.append(message.model_dump(exclude_none=True)) |
| ''' |
|
|
|
|
| def loop_span(source: str) -> tuple[int, int]: |
| function = next(node for node in ast.parse(source).body |
| if isinstance(node, ast.AsyncFunctionDef) and node.name == "run_chat_loop") |
| return function.lineno - 1, function.end_lineno |
|
|
|
|
| def patch_source(source: str) -> str: |
| lines = source.splitlines(keepends=True) |
| start, end = loop_span(source) |
| current = "".join(lines[start:end]) |
| if "recovery_setting = " in current: |
| original = current.replace(_INITIALIZE, "", 1).replace(_RECOVERY_REPLY, _ORIGINAL_REPLY, 1) |
| if original == current or hashlib.sha256(original.encode()).hexdigest() != ORIGINAL_LOOP_SHA256: |
| raise RuntimeError("Recovery patch changed; refusing an unreviewed patch") |
| return source |
| if hashlib.sha256(current.encode()).hexdigest() != ORIGINAL_LOOP_SHA256: |
| raise RuntimeError("Upstream Bash loop changed; refusing an unreviewed patch") |
| assert current.count(" while True:\n") == current.count(_ORIGINAL_REPLY) == 1 |
| replacement = current.replace(" while True:\n", _INITIALIZE + " while True:\n", 1) |
| replacement = replacement.replace(_ORIGINAL_REPLY, _RECOVERY_REPLY, 1) |
| updated = "".join(lines[:start]) + replacement + "".join(lines[end:]) |
| ast.parse(updated) |
| return updated |
|
|
|
|
| def verify_runtime(expected_sha256: str) -> dict[str, str]: |
| """Use Python's installed module location in both CPU and GPU checks.""" |
| spec = importlib.util.find_spec("verifiers.v1.harnesses.utils.core") |
| if spec is None or spec.origin is None: |
| raise RuntimeError("Installed Verifiers Bash module was not found") |
| path = Path(spec.origin) |
| source = path.read_text() |
| assert patch_source(source) == source and "recovery_used = False" in source |
| from verifiers.v1.harnesses.utils.launch import CHAT_PROGRAM_SOURCE |
| assert "recovery_used = False" in CHAT_PROGRAM_SOURCE |
| compile(CHAT_PROGRAM_SOURCE, "<bundled-bash>", "exec") |
| assert hashlib.sha256(Path(__file__).read_bytes()).hexdigest() == expected_sha256 |
| return {"core_path": str(path), "core_sha256": hashlib.sha256(source.encode()).hexdigest(), |
| "bundle_sha256": hashlib.sha256(CHAT_PROGRAM_SOURCE.encode()).hexdigest()} |
|
|
|
|
| def install() -> None: |
| if importlib.metadata.version("verifiers") != "0.4.1.dev12": |
| raise RuntimeError("Recovery patch requires reviewed Verifiers 0.4.1.dev12") |
| package = importlib.util.find_spec("verifiers") |
| path = Path(package.origin).parent / "v1/harnesses/utils/core.py" |
| source = path.read_text() |
| updated = patch_source(source) |
| if updated != source: |
| path.write_text(updated) |
| for cached in (path.parent / "__pycache__").glob("core.*.pyc"): |
| cached.unlink() |
| py_compile.compile(str(path), doraise=True, |
| invalidation_mode=py_compile.PycInvalidationMode.CHECKED_HASH) |
| print("Bash length recovery installed; disabled unless VF_BASH_LENGTH_RECOVERY=1") |
|
|
|
|
| if __name__ == "__main__": |
| install() |
|
|
