| """OpenEnv transport for the unmodified MiMo software-task verifier.""" |
|
|
| import json |
| import os |
| from pathlib import Path |
| import shutil |
| import shlex |
| import signal |
| import subprocess |
| import tarfile |
| import tempfile |
| from typing import Literal |
| import uuid |
|
|
| from mimoagent.environments.datasets.opensource_code import OpenSourceCodeEnvironment |
| from mimoagent.environments.local import LocalEnvironment |
| from openenv.core.env_server import Action, Environment, Observation, State, create_app |
| from pydantic import Field |
|
|
|
|
| ROOT = Path(__file__).resolve().parent |
| INSTANCE = json.loads((ROOT / "instance.json").read_text()) |
| WORKSPACE = Path(INSTANCE["cwd"]) |
| AGENT_UID = 2000 |
| OUTPUT_LIMIT = 12000 |
|
|
|
|
| class ShellAction(Action): |
| operation: Literal["shell", "finish"] = Field(description="Run a bash command or finish and grade the repository.") |
| command: str = Field(default="", max_length=16000, description="Bash command; each call starts in the task repository.") |
|
|
|
|
| class ShellObservation(Observation): |
| task_id: str |
| output: str = Field(max_length=16000) |
| exit_code: int | None = None |
|
|
|
|
| class VerifierExecution(LocalEnvironment): |
| """Keep upstream verifier operations in the container, with bounded processes.""" |
|
|
| def __init__(self, *, privileged=False, **kwargs): |
| super().__init__(**kwargs) |
| self.privileged = privileged |
|
|
| def execute(self, command, cwd="", timeout=None): |
| return run_command(command, cwd or str(WORKSPACE), timeout or 120, |
| agent=not self.privileged) |
|
|
| def copy_to(self, src_path, dest_path, **kwargs): |
| with open(src_path, "rb") as source: |
| result = run_command("cat > " + shlex.quote(dest_path), str(WORKSPACE), |
| 120, agent=not self.privileged, stdin=source) |
| if result["returncode"] != 0: |
| raise RuntimeError("Verifier file transfer failed") |
|
|
|
|
| def run_command(command, cwd, timeout, *, agent, stdin=None): |
| env = dict(os.environ) |
| env.pop("PYTHONPATH", None) |
| if agent: |
| env.update(HOME="/home/arena-agent", USER="arena-agent", LOGNAME="arena-agent") |
| |
| with tempfile.TemporaryFile() as output: |
| proc = subprocess.Popen( |
| ["/bin/bash", "-c", command], cwd=cwd, env=env, |
| stdin=stdin, stdout=output, stderr=subprocess.STDOUT, start_new_session=True, |
| user=AGENT_UID if agent else None, |
| group=AGENT_UID if agent else None, |
| extra_groups=[] if agent else None, |
| ) |
| timed_out = False |
| try: |
| proc.wait(timeout=timeout) |
| except subprocess.TimeoutExpired: |
| timed_out = True |
| finally: |
| try: |
| os.killpg(proc.pid, signal.SIGKILL) |
| except ProcessLookupError: |
| pass |
| proc.wait() |
| length = output.tell() |
| output.seek(max(0, length - OUTPUT_LIMIT)) |
| text = output.read(OUTPUT_LIMIT).decode("utf-8", "replace") |
| if length > OUTPUT_LIMIT: |
| text = "[output truncated to final 12000 bytes]\n" + text |
| if timed_out: |
| text += "\n[command timed out]" |
| return {"output": text, "returncode": 124 if timed_out else proc.returncode} |
|
|
|
|
| class MiMoEnvironment(Environment): |
| def __init__(self): |
| super().__init__() |
| self._state = State() |
| self.verifier = None |
| self.terminal = None |
|
|
| def reset(self, seed=None, episode_id=None, task_id=None, **kwargs): |
| if task_id not in (None, INSTANCE["instance_id"]): |
| raise ValueError("This image does not contain that task_id") |
| if WORKSPACE not in (Path("/testbed"), Path("/workspace/repo")): |
| raise RuntimeError("Unsupported workspace in pinned task") |
| if WORKSPACE.exists(): |
| shutil.rmtree(WORKSPACE) |
| with tarfile.open(ROOT / "workspace.tar") as archive: |
| archive.extractall(WORKSPACE.parent, filter="fully_trusted") |
| subprocess.run(["chown", "-R", f"{AGENT_UID}:{AGENT_UID}", str(WORKSPACE)], check=True) |
| self.verifier = OpenSourceCodeEnvironment(VerifierExecution(cwd=str(WORKSPACE)), INSTANCE) |
| self.verifier.setup_environment() |
| self._state = State(episode_id=episode_id or str(uuid.uuid4()), step_count=0) |
| self.terminal = None |
| instruction = ( |
| INSTANCE["problem_statement"] |
| + f"\n\nRepository: {WORKSPACE}. Use shell actions to inspect, edit, and test it. " |
| 'Return {"operation":"finish"} when ready for the original MiMo tests. ' |
| "Each shell call starts in the repository; use cd within a command as needed. " |
| "Commands time out after 60 seconds and output is truncated." |
| ) |
| return ShellObservation(task_id=INSTANCE["instance_id"], output=instruction, reward=0.0) |
|
|
| def step(self, action, timeout_s=None, **kwargs): |
| if self.verifier is None: |
| raise RuntimeError("reset is required before step") |
| if self.terminal is not None: |
| return self.terminal |
| self._state.step_count += 1 |
| if action.operation == "finish" or self._state.step_count >= 64: |
| reward, output, info = self.verifier.calculate_reward(timeout=INSTANCE["verifier_timeout_sec"]) |
| if info.get("error_category") or info.get("transport_error") or "verifier_returncode" not in info: |
| raise RuntimeError("MiMo verifier infrastructure failed; no valid reward") |
| self.terminal = ShellObservation( |
| task_id=INSTANCE["instance_id"], output="Original MiMo verifier completed.", |
| exit_code=info["verifier_returncode"], reward=float(reward), done=True, |
| ) |
| return self.terminal |
| result = run_command(action.command, str(WORKSPACE), min(60, timeout_s or 60), agent=True) |
| return ShellObservation(task_id=INSTANCE["instance_id"], output=result["output"], exit_code=result["returncode"], reward=0.0) |
|
|
| @property |
| def state(self): |
| return self._state |
|
|
|
|
| app = create_app(MiMoEnvironment, ShellAction, ShellObservation, env_name="mimo_software", max_concurrent_envs=1) |
|
|
