Blame for common/source/starBenchserver/benchmarks/simBenchmarks/LIBERO-plus/bench_server/adapter.py

"""LIBERO-Plus native direct-control adapter, with no simulator import at startup."""
from __future__ import annotations

import hashlib
import importlib
import importlib.metadata
import json
import os
from pathlib import Path
import subprocess
import sys
from typing import Any, Mapping, Sequence
import xml.etree.ElementTree as ET

from benchkit.artifacts import append_jsonl, atomic_write_json
from benchkit.contracts import ActionSpec, BenchmarkDescriptor, EpisodeSpec, JsonValue, Observation, ObservationSpec, Transition
from benchkit.errors import CompatibilityError, ProtocolError
from benchkit.registry import register_benchmark

from .protocol.catalog import COUNTS, HORIZONS, REVISION, file_sha256, native_files, task_catalog

CAMERAS = ("agentview", "robot0_eye_in_hand")
SETTLE_STEPS = 10
PACKAGE_PINS = {"robosuite": "1.4.0", "mujoco": "3.2.3", "numpy": "1.24.4", "torch": "2.5.1+cpu",
                "Wand": "0.6.13", "scikit-image": "0.24.0"}
IMPORT_SUFFIXES = (".py", ".pyc", ".pyo", ".so", ".pyd", ".dll")


def verify_native_import_inventory(root: Path, rows: Sequence[Mapping[str, Any]]) -> None:
    """Reject source/extension/cache overrides in the executed native package.

    Released assets and BDDL/reset data are checked by separate receipts. They
    are not recursively scanned as import code, nor is unused lifelong code.
    This is a filesystem inventory, not attestation of loaded Python memory.
    """
    namespace, package = root / "libero", root / "libero/libero"
    for directory in (namespace, package):
        if directory.is_symlink() or not directory.is_dir():
            raise CompatibilityError("native package must be a regular directory")
    # This pin intentionally has a namespace package at the outer libero level.
    # A new __init__.py or extension there would execute before origin checks.
    if any(path.name.endswith(IMPORT_SUFFIXES) for path in namespace.iterdir() if not path.is_dir()):
        raise CompatibilityError("unrecorded native namespace import file")
    expected = {row["path"] for row in rows if row["path"].endswith(".py")}
    actual = set()
    count = 0
    for directory, children, filenames in os.walk(package, followlinks=False):
        if Path(directory) == package:
            children[:] = [name for name in children if name not in {"assets", "bddl_files", "init_files"}]
        for name in children:
            if (Path(directory) / name).is_symlink():
                raise CompatibilityError("native import directory symlink is not pinned")
        count += len(children) + len(filenames)
        if count > 1000:
            raise CompatibilityError("native import inventory exceeds its bound")
        for name in filenames:
            if not name.endswith(IMPORT_SUFFIXES):
                continue
            path = Path(directory) / name
            relative = path.relative_to(root).as_posix()
            if path.is_symlink() or not path.is_file() or relative not in expected:
                raise CompatibilityError("unrecorded native source, bytecode or extension import file")
            actual.add(relative)
    if actual != expected:
        raise CompatibilityError("native Python import inventory differs from the frozen source manifest")


def image_magick_receipt() -> dict:
    """Actual native sensor-noise backend, not just the Python Wand version."""
    from wand import version
    return {"version": version.MAGICK_VERSION, "features": version.MAGICK_VERSION_FEATURES,
            "quantum_depth": version.QUANTUM_DEPTH, "hdri": version.MAGICK_HDRI,
            "scope": "loaded library reports; not binary or library-dependency attestation"}


def policy_observation(raw: Mapping[str, Any], step: int, instruction: str) -> Observation:
    """Two independent RGB copies only; preserve upstream perturbations exactly."""
    import numpy as np

    images = {}
    for camera in CAMERAS:
        frame = np.asarray(raw.get(camera + "_image"))
        if frame.dtype != np.uint8 or frame.shape != (256, 256, 3):
            raise ProtocolError("LIBERO-Plus requires two 256x256 uint8 RGB observations")
        images[camera] = np.ascontiguousarray(frame[::-1, ::-1]).copy()
    return Observation(step=step, instruction=instruction, images=images)


def verify_native_source(root: Path) -> dict:
    """Verify bounded native source inputs before loading torch or the simulator."""
    env = {**os.environ, "GIT_OPTIONAL_LOCKS": "0"}
    try:
        top = subprocess.run(["git", "-C", str(root), "rev-parse", "--show-toplevel"],
                             capture_output=True, text=True, check=True, timeout=20, env=env).stdout.strip()
        revision = subprocess.run(["git", "-C", str(root), "rev-parse", "HEAD"],
                                  capture_output=True, text=True, check=True, timeout=20, env=env).stdout.strip()
    except (OSError, subprocess.SubprocessError) as exc:
        raise CompatibilityError("cannot verify the LIBERO-Plus native checkout") from exc
    if Path(top).resolve() != root or revision != REVISION:
        raise CompatibilityError(f"LIBERO-Plus requires its own native checkout at {REVISION}")
    manifest_path = Path(__file__).parents[1] / "environment" / "native_source_manifest.json"
    payload = json.loads(manifest_path.read_text())
    if (payload.get("schema_version") != "starvla-rsi.libero-plus-native-source/v1"
            or payload.get("upstream_revision") != REVISION or not payload.get("files")
            or len(payload["files"]) > 200):
        raise CompatibilityError("native source inventory differs")
    verify_native_import_inventory(root, payload["files"])
    for item in payload["files"]:
        path = (root / item["path"]).resolve()
        if (not path.is_relative_to(root) or path.stat().st_size != item["size_bytes"]
                or file_sha256(path, max_bytes=4 * 1024 * 1024) != item["sha256"]):
            raise CompatibilityError("native source differs from the frozen source inventory")
    return {"manifest_sha256": file_sha256(manifest_path), "files": payload["files"], "scope": payload["scope"]}


def prepare_native_import(root: Path) -> dict:
    source = verify_native_source(root)
    for package, expected in PACKAGE_PINS.items():
        try:
            actual = importlib.metadata.version(package)
        except importlib.metadata.PackageNotFoundError as exc:
            raise CompatibilityError(f"missing required LIBERO-Plus package {package}") from exc
        if actual != expected:
            raise CompatibilityError(f"LIBERO-Plus requires {package}=={expected}, got {actual}")
    config = os.environ.get("LIBERO_CONFIG_PATH")
    if not config or not (Path(config) / "config.yaml").is_file():
        raise CompatibilityError("set LIBERO_CONFIG_PATH to an isolated, pre-created config directory")
    # Namespace packages are used by this pin. Never silently reuse a different
    # installed standard-LIBERO namespace or alter an already imported runtime.
    if "libero" in sys.modules:
        locations = tuple(Path(path).resolve() for path in getattr(sys.modules["libero"], "__path__", ()))
        if locations != (root / "libero",):
            raise CompatibilityError("another LIBERO namespace is already loaded in this process")
    if str(root) not in sys.path:
        sys.path.insert(0, str(root))
    native = importlib.import_module("libero.libero")
    if Path(native.__file__).resolve() != root / "libero/libero/__init__.py":
        raise CompatibilityError("imported LIBERO namespace differs from the selected Plus checkout")
    for field, suffix in (("benchmark_root", ""), ("bddl_files", "bddl_files"),
                          ("init_states", "init_files"), ("assets", "assets")):
        expected = root / "libero/libero" / suffix
        if Path(native.get_libero_path(field)).resolve() != expected or not expected.is_dir():
            raise CompatibilityError(f"LIBERO-Plus {field} must resolve inside the pinned native checkout")
    return source


def selected_asset_receipt(native_env: Any, root: Path, robosuite_root: Path) -> dict:
    """Hash only files explicitly referenced by the constructed native XML.

    This is not an attestation of all 16 GB of released assets or loaded GPU
    memory. The receipt never crosses the policy observation boundary.
    """
    text = native_env.model.get_xml()
    if not isinstance(text, str) or len(text.encode()) > 8 * 1024 * 1024:
        raise CompatibilityError("native XML exceeds the asset-receipt bound")
    document = ET.fromstring(text)
    allowed = {"libero_plus_assets": root / "libero/libero/assets",
               "robosuite_assets": robosuite_root / "models/assets"}
    paths = {}
    unresolved = []
    compiler = document.find("compiler")
    compiler = {} if compiler is None else compiler.attrib
    for element in document.findall(".//asset/*"):
        filename = element.get("file")
        if not filename:
            continue
        path = Path(filename)
        if not path.is_absolute():
            directory = compiler.get("meshdir" if element.tag == "mesh" else "texturedir", "")
            path = Path(directory) / path
        if not path.is_absolute():
            unresolved.append({"tag": element.tag, "file": filename})
            continue
        path = path.resolve()
        match = next(((label, base) for label, base in allowed.items() if path.is_relative_to(base.resolve())), None)
        if match is None:
            raise CompatibilityError("native asset reference leaves the declared source/package asset roots")
        label, base = match
        key = label + "/" + path.relative_to(base.resolve()).as_posix()
        paths[key] = path
    if len(paths) > 2048 or sum(path.stat().st_size for path in paths.values()) > 2 * 1024**3:
        raise CompatibilityError("selected native asset receipt exceeds its declared bound")
    return {"scope": "constructed XML mesh/texture file references, not complete asset or GPU-memory attestation",
            "native_model_xml_sha256": hashlib.sha256(text.encode()).hexdigest(),
            "files": [{"path": name, "size_bytes": path.stat().st_size,
                       "sha256": file_sha256(path, max_bytes=256 * 1024**2)} for name, path in sorted(paths.items())],
            "unresolved_relative_references": unresolved}


class LiberoPlusEpisode:
    def __init__(self, adapter: LiberoPlusBenchmarkAdapter, episode: EpisodeSpec):
        self.benchmark, self.episode = adapter, episode
        self.env = None
        self.artifact_dir: Path | None = None
        self.writers: dict[str, Any] = {}
        self.step_count = 0
        self.control_attempts = 0
        self.settle_count = 0
        self.settle_attempts = 0
        self.uncertain_controls = 0
        self.success = False
        self.finished = False
        self.reset_claimed = False
        self.initialized = False
        self.closed = False
        self.finalized = False
        self.close_error: Exception | None = None
        self.provenance: dict[str, Any] | None = None

    def bind_artifact_dir(self, path: Path) -> None:
        if self.artifact_dir is not None or self.reset_claimed or self.finalized or self.closed:
            raise ProtocolError("artifact directory must be bound once before reset")
        self.artifact_dir = path
        path.mkdir(parents=True, exist_ok=True)

    def reset(self) -> Observation:
        if self.reset_claimed or self.closed or self.finalized:
            raise ProtocolError("LIBERO-Plus session permits exactly one reset attempt")
        self.reset_claimed = True
        try:
            return self._reset_once()
        except Exception:
            self.finished = True
            raise

    def _reset_once(self) -> Observation:
        root = self.benchmark.upstream
        source = prepare_native_import(root)
        import numpy as np
        import robosuite
        from libero.libero import benchmark as native_benchmark
        from libero.libero.envs import OffScreenRenderEnv

        suite = native_benchmark.get_benchmark_dict()[self.benchmark.suite](task_order_index=0)
        task_id = self.episode.metadata["native_id"]
        task = suite.get_task(task_id)
        row = self.benchmark.catalog["tasks"][task_id]
        if (suite.n_tasks != COUNTS[self.benchmark.suite] or task.name != row["native_name"]
                or task.language != row["native_instruction"] or task.problem_folder != self.benchmark.suite
                or task.bddl_file != task.name + ".bddl" or task.init_states_file != task.name + ".pruned_init"):
            raise CompatibilityError("native LIBERO-Plus identity/order differs from frozen selection")
        paths = native_files(self.benchmark.suite, task.name)
        bddl = root / "libero/libero/bddl_files" / paths["bddl"]
        virtual_bddl = root / "libero/libero/bddl_files" / paths["virtual_bddl"]
        initial_file = root / "libero/libero/init_files" / row["initial_file"]
        if file_sha256(bddl) != row["bddl_sha256"] or file_sha256(initial_file) != row["initial_file_sha256"]:
            raise CompatibilityError("selected BDDL/reset file differs from the frozen catalog")
        initial_states = suite.get_task_init_states(task_id)
        if file_sha256(initial_file) != row["initial_file_sha256"]:
            raise CompatibilityError("reset file changed while the native loader read it")
        states = np.asarray(initial_states)
        if states.ndim != 2 or not 1 <= len(states) <= 1000 or not 1 <= states.shape[1] <= 10000 or not np.isfinite(states).all():
            raise CompatibilityError("native initial states must be a finite bounded matrix")
        controller = robosuite.load_controller_config(default_controller="OSC_POSE")
        if (controller["input_min"] != -1 or controller["input_max"] != 1
                or controller["output_max"] != [0.05, 0.05, 0.05, 0.5, 0.5, 0.5]
                or controller["output_min"] != [-0.05, -0.05, -0.05, -0.5, -0.5, -0.5]
                or controller["control_delta"] is not True):
            raise CompatibilityError("native OSC_POSE controller differs from declared normalized control")
        self.provenance = {"upstream_revision": REVISION, "native_source": source,
            "suite": self.benchmark.suite, "task_order_index": 0, "native_id": task_id,
            "native_name": task.name, "category": row["category"], "difficulty_level": row["difficulty_level"],
            "native_filename_instruction": task.language, "public_instruction_source": "backing BDDL :language",
            "initial_state_index": 0, "available_initial_states": len(states), "reset_seed": self.episode.seed,
            "bddl_file": paths["bddl"], "virtual_bddl_file": paths["virtual_bddl"],
            "bddl_sha256": row["bddl_sha256"], "initial_file": row["initial_file"],
            "initial_file_sha256": row["initial_file_sha256"],
            "selected_state_sha256": hashlib.sha256(states[0].tobytes()).hexdigest(),
            "declared_settle_steps": SETTLE_STEPS, "controller": controller,
            "native_engine_horizon": self.benchmark.native_engine_horizon,
            "image_transform": "native RGB[::-1,::-1] copied; native sensor perturbations untouched",
            "image_magick": image_magick_receipt(),
            "versions": {name: importlib.metadata.version(name) for name in (*PACKAGE_PINS, "Pillow", "imageio", "imageio-ffmpeg", "PyOpenGL")},
            **self.benchmark.budget_metadata()}
        self._write_provenance()
        np.random.seed(self.episode.seed)
        self._event("native_construct_start")
        self.env = OffScreenRenderEnv(bddl_file_name=str(virtual_bddl), camera_heights=256, camera_widths=256,
            camera_names=list(CAMERAS), camera_depths=False, camera_segmentations=None, control_freq=20,
            horizon=self.benchmark.native_engine_horizon, render_gpu_device_id=self.benchmark.render_gpu_device_id)
        self._event("native_construct_end")
        low, high = self.env.env.action_spec
        if not np.array_equal(low, np.full(7, -1.0)) or not np.array_equal(high, np.full(7, 1.0)):
            raise CompatibilityError("native action bounds must be 7D [-1, 1]")
        self.env.seed(self.episode.seed)
        self._event("native_reset_start")
        self.env.reset()
        self._event("native_reset_end")
        self._event("native_initial_state_start")
        raw = self.env.set_init_state(initial_states[0])
        self._event("native_initial_state_end")
        self.provenance["selected_assets"] = selected_asset_receipt(self.env.env, root, Path(robosuite.__file__).resolve().parent)
        self._write_provenance()
        for _ in range(SETTLE_STEPS):
            raw, _reward, done, _info = self._native_control([0.0] * 6 + [-1.0], settle=True)
            if bool(done):
                raise ProtocolError("native success occurred during initialization before a policy action")
        observation = self._observe(raw)
        self.initialized = True
        return observation

    def _event(self, event: str, **fields) -> None:
        if self.artifact_dir is not None:
            append_jsonl(self.artifact_dir / "native_events.jsonl", {"event": event, **fields})

    def _native_control(self, action, *, settle=False):
        phase = "settle" if settle else "policy"
        index = (self.settle_attempts if settle else self.control_attempts) + 1
        self._event("native_control_start", phase=phase, attempt=index, action=list(action))
        if settle:
            self.settle_attempts += 1
        else:
            self.control_attempts += 1
        try:
            returned = self.env.step(list(action))
        except Exception:
            # The native call may have partly advanced before raising. Do not
            # guess how much or permit the same action to be replayed.
            self.uncertain_controls += 1
            self.finished = True
            raise
        if settle:
            self.settle_count += 1
        else:
            self.step_count += 1
        self._event("native_control_end", phase=phase, attempt=index,
                    completed_controls=self.settle_count if settle else self.step_count)
        return returned

    def _write_provenance(self) -> None:
        if self.artifact_dir is not None and self.provenance is not None:
            atomic_write_json(self.artifact_dir / "native_provenance.json", self.provenance)

    def _observe(self, raw: Mapping[str, Any]) -> Observation:
        observation = policy_observation(raw, self.step_count, self.episode.instruction)
        if self.artifact_dir is not None:
            import imageio.v2 as imageio
            from PIL import Image
            for camera, frame in observation.images.items():
                path = self.artifact_dir / f"{camera}-{self.step_count:06d}.png"
                Image.fromarray(frame).save(path)
                if camera not in self.writers:
                    self.writers[camera] = imageio.get_writer(str(self.artifact_dir / f"{camera}.mp4"),
                        fps=20, codec="libx264", macro_block_size=1)
                self.writers[camera].append_data(frame)
                append_jsonl(self.artifact_dir / "frames.jsonl", {"camera": camera, "step": self.step_count,
                    "path": path.name, "sha256": file_sha256(path), "instruction": self.episode.instruction})
        return observation

    def step(self, action: tuple[float, ...]) -> Transition:
        if self.env is None or not self.initialized or self.finished or self.closed or self.finalized:
            raise ProtocolError("cannot step an uninitialized/finished LIBERO-Plus session")
        action = self.benchmark.action_spec.validate(action)
        try:
            raw, reward, done, _private_info = self._native_control(action)
            # BDDLBaseDomain.step already assigns done = _check_success(). No
            # extra scorer query or privileged field is used.
            self.success = bool(done)
            truncated = self.step_count >= self.benchmark.environment_step_cap and not self.success
            self.finished = self.success or truncated
            return Transition(observation=self._observe(raw), reward=float(reward), terminated=self.success,
                              truncated=truncated, info={"native_success": self.success, "native_steps": self.step_count})
        except Exception:
            self.finished = True
            raise

    def metrics(self) -> Mapping[str, JsonValue]:
        return {"success": self.success, "native_steps": self.step_count, "settle_steps": self.settle_count,
                "declared_settle_steps": SETTLE_STEPS, "native_control_attempts": self.control_attempts,
                "settle_control_attempts": self.settle_attempts, "uncertain_native_controls": self.uncertain_controls,
                **self.benchmark.budget_metadata()}

    def _close_writers(self) -> None:
        errors = []
        for camera, writer in list(self.writers.items()):
            try:
                writer.close()
            except Exception as exc:
                errors.append(exc)
            finally:
                del self.writers[camera]
        if errors:
            raise errors[0]

    def artifacts(self) -> Mapping[str, str]:
        self.finalized = True
        self._close_writers()
        if self.artifact_dir is None:
            return {}
        names = {camera + "_video": camera + ".mp4" for camera in CAMERAS}
        names.update(frames="frames.jsonl", native_provenance="native_provenance.json", native_events="native_events.jsonl")
        return {key: str(self.artifact_dir / name) for key, name in names.items() if (self.artifact_dir / name).is_file()}

    def close(self) -> None:
        if self.closed:
            if self.close_error is not None:
                raise self.close_error
            return
        self.closed = True
        self.finalized = True
        self.finished = True
        errors = []
        try:
            self._close_writers()
        except Exception as exc:
            errors.append(exc)
        if self.env is not None:
            native, self.env = self.env, None
            try:
                native.close()
            except Exception as exc:
                errors.append(exc)
        if errors:
            self.close_error = errors[0]
            raise self.close_error


class LiberoPlusBenchmarkAdapter:
    """One explicit fast subset, native order, state 0, one attempt per task."""
    def __init__(self, *, upstream: str, suite: str = "libero_spatial", task_ids: Sequence[int] = (0,),
                 evaluation_mode: str = "fast", render_gpu_device_id: int = 0,
                 budget_mode: str = "horizon", max_policy_calls: int | None = None,
                 replan_interval: int | None = None):
        if not isinstance(upstream, str) or not Path(upstream).is_absolute():
            raise ValueError("upstream must be an absolute server-local native checkout path")
        if evaluation_mode != "fast":
            raise ValueError("only explicit fast selections are supported; full native parity is not validated")
        self.catalog = task_catalog(suite)
        if (not isinstance(task_ids, (list, tuple)) or not task_ids
                or any(type(index) is not int or not 0 <= index < COUNTS[suite] for index in task_ids)
                or list(task_ids) != sorted(set(task_ids))):
            raise ValueError("task_ids must be a nonempty unique increasing subset of native indices")
        if type(render_gpu_device_id) is not int or render_gpu_device_id < 0:
            raise ValueError("render_gpu_device_id must be a nonnegative integer")
        if budget_mode not in ("horizon", "decisions"):
            raise ValueError("budget_mode must be horizon or decisions")
        if budget_mode == "decisions":
            if any(type(value) is not int or not 1 <= value <= 10000 for value in (max_policy_calls, replan_interval)):
                raise ValueError("decision budgets require positive bounded max_policy_calls and replan_interval")
            cap = max_policy_calls * replan_interval
            if cap > 10000:
                raise ValueError("maximum declared environment controls is 10000")
        else:
            if max_policy_calls is not None or replan_interval is not None:
                raise ValueError("adapter decision parameters require budget_mode=decisions")
            cap = HORIZONS[suite]
        self.upstream = Path(upstream).resolve()
        self.suite, self.task_ids = suite, tuple(task_ids)
        self.render_gpu_device_id = render_gpu_device_id
        self.budget_mode, self.max_policy_calls, self.replan_interval = budget_mode, max_policy_calls, replan_interval
        self.environment_step_cap = self.evaluation_horizon = cap
        self.native_engine_horizon = max(1000, cap + SETTLE_STEPS)
        self.opened: set[tuple[str, int]] = set()
        budget = f"decision-{max_policy_calls}-prefix-{replan_interval}" if budget_mode == "decisions" else "reference-horizon"
        self.descriptor = BenchmarkDescriptor(name="libero_plus", version="0.1.0",
            protocol_version=f"libero-plus-fast/{suite}/rgb/{budget}/v1", source_revision=REVISION)
        self.observation_spec = ObservationSpec(cameras=CAMERAS, modalities=("language", "rgb"))
        self.action_spec = ActionSpec(mode="normalized_osc_delta_pose", size=7,
            names=("dx_scaled", "dy_scaled", "dz_scaled", "rx_scaled", "ry_scaled", "rz_scaled", "gripper"),
            low=(-1.0,) * 7, high=(1.0,) * 7, control_hz=20.0,
            frame="world: translation component 1 means +0.05 m",
            rotation="world axis-angle delta: rotation component 1 means +0.5 rad",
            gripper="-1 open; +1 close; 0 hold native gripper target")

    def budget_metadata(self) -> dict[str, JsonValue]:
        return {"evaluation_mode": "fast", "budget_mode": self.budget_mode,
                "max_policy_calls": self.max_policy_calls, "replan_interval": self.replan_interval,
                "environment_step_cap": self.environment_step_cap, "native_horizon": HORIZONS[self.suite],
                "native_horizon_source": "retained_starvla_libero_plus_evaluator_reference",
                "evaluation_horizon": self.evaluation_horizon}

    def episodes(self, seed: int, limit: int | None = None) -> Sequence[EpisodeSpec]:
        if type(seed) is not int or not 0 <= seed < 2**32:
            raise ValueError("seed must be a predeclared uint32 integer")
        if limit is not None and (type(limit) is not int or not 1 <= limit <= len(self.task_ids)):
            raise ValueError("limit must select a nonempty prefix without repeats")
        rows = [self.catalog["tasks"][index] for index in self.task_ids[:limit]]
        return [EpisodeSpec(id=f"{self.suite}-task{row['native_id']:04d}-init00", seed=seed,
            task=f"{self.suite}/task-{row['native_id']}", instruction=row["instruction"],
            metadata={"suite": self.suite, "native_id": row["native_id"], "native_name": row["native_name"],
                      "category": row["category"], "difficulty_level": row["difficulty_level"],
                      "task_order_index": 0, "initial_state_index": 0, "attempt": 1,
                      "settle_steps": SETTLE_STEPS, **self.budget_metadata()}) for row in rows]

    def open_episode(self, episode: EpisodeSpec) -> LiberoPlusEpisode:
        key = (episode.id, episode.seed)
        if episode not in self.episodes(episode.seed) or key in self.opened:
            raise ProtocolError("episode differs from selection or was already attempted")
        self.opened.add(key)
        return LiberoPlusEpisode(self, episode)


@register_benchmark("libero_plus")
def make_libero_plus(parameters: Mapping[str, JsonValue]) -> LiberoPlusBenchmarkAdapter:
    allowed = {"upstream", "suite", "task_ids", "evaluation_mode", "render_gpu_device_id",
               "budget_mode", "max_policy_calls", "replan_interval"}
    if not isinstance(parameters, Mapping) or set(parameters) - allowed:
        raise ValueError("unknown LIBERO-Plus adapter parameters")
    return LiberoPlusBenchmarkAdapter(**parameters)