| """Export a closed run's results without requiring interaction logs or source audits. |
| |
| Any trusted driver may emit the documented JSON record contract. Python Policy, |
| model transcripts, event streams and source snapshots are not admission gates. |
| Validation here establishes record consistency, not native/provider attestation. |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import html |
| import json |
| import math |
| import os |
| from pathlib import Path |
| import re |
| import tempfile |
|
|
| from benchkit.audits.closed_run import ClosedFiles, counter, require |
| from benchkit.methods import (USAGE_FIELDS, method_from_policy, normalize_method, |
| normalize_usage, normalize_component_usage, sum_component_usage) |
|
|
| SCHEMA = "starvla-rsi.basic-result/v1" |
| MAX_BYTES = 128 * 1024 * 1024 |
| MAX_EPISODES = 10000 |
|
|
|
|
| class _Files(ClosedFiles): |
| def __init__(self, root): |
| require(not Path(root).is_symlink(), "run root must not be a symlink") |
| super().__init__(Path(root)) |
| self.sizes = {} |
| self.total = 0 |
|
|
| def raw(self, relative): |
| size = self.path(relative).stat().st_size |
| require(self.total + size <= MAX_BYTES, "result input exceeds total byte limit") |
| data = super().raw(relative) |
| self.total += len(data) |
| self.sizes[relative] = len(data) |
| require(self.total <= MAX_BYTES, "result input exceeds total byte limit") |
| return data |
|
|
| def verify_unchanged(self): |
| for relative, expected in self.hashes.items(): |
| path = self.path(relative) |
| remaining = self.sizes[relative] |
| require(path.stat().st_size == remaining, "record changed during export") |
| digest = hashlib.sha256() |
| with path.open("rb") as stream: |
| while remaining: |
| block = stream.read(min(65536, remaining)) |
| require(bool(block), "record changed during export") |
| remaining -= len(block) |
| digest.update(block) |
| require(not stream.read(1), "record changed during export") |
| require(digest.hexdigest() == expected, "record changed during export") |
|
|
|
|
| def _object(value, label): |
| require(type(value) is dict, label + " must be an object") |
| return value |
|
|
|
|
| def _text(value, label, *, optional=False): |
| if optional and value is None: |
| return None |
| require(isinstance(value, str) and 0 < len(value) <= 4096 |
| and not any(ord(c) < 32 or 0xD800 <= ord(c) <= 0xDFFF for c in value), |
| "invalid " + label) |
| require(not value.startswith(("/", "~/", "\\\\")) |
| and re.match(r"^[A-Za-z]:[\\/]", value) is None, "private path in " + label) |
| return value |
|
|
|
|
| def _same(left, right): |
| if type(left) is bool or type(right) is bool: |
| return type(left) is type(right) and left == right |
| if type(left) is dict and type(right) is dict: |
| return set(left) == set(right) and all(_same(left[k], right[k]) for k in left) |
| if type(left) in (float, int) and type(right) in (float, int): |
| return math.isclose(left, right, rel_tol=1e-9, abs_tol=1e-9) |
| return left == right |
|
|
|
|
| def _sum_usage(rows): |
| out = dict.fromkeys(USAGE_FIELDS, 0) |
| for row in rows: |
| usage = normalize_usage(row.get("usage")) |
| out = {key: None if out[key] is None or usage[key] is None else out[key] + usage[key] |
| for key in USAGE_FIELDS} |
| return out |
|
|
|
|
| def _metric_keys(values): |
| require(isinstance(values, (tuple, list)) and len(values) <= 64, "invalid metric selection") |
| require(all(isinstance(key, str) and re.fullmatch(r"[A-Za-z][A-Za-z0-9_.-]{0,127}", key) |
| for key in values), "invalid metric key") |
| require(len(values) == len(set(values)), "duplicate metric selection") |
| return list(values) |
|
|
|
|
| def _public_contracts(manifest): |
| result = {} |
| for name, labels, lists in (("action_spec", ("mode", "frame", "rotation", "gripper"), ("names",)), |
| ("observation_spec", ("control_feedback_schema",), |
| ("cameras", "state_names", "modalities"))): |
| value = _object(manifest.get(name), name) |
| row = {key: _text(value.get(key), key, optional=True) for key in labels} |
| for key in lists: |
| items = value.get(key, []) |
| require(type(items) is list and len(items) <= 4096, "invalid contract list") |
| row[key] = [_text(item, key) for item in items] |
| if name == "action_spec": |
| row["size"] = counter(value.get("size"), "action size") |
| require(0 < row["size"] <= 4096, "invalid action size") |
| require(not row["names"] or len(row["names"]) == row["size"], "action names/dimension mismatch") |
| hz = value.get("control_hz") |
| require(hz is None or type(hz) in (int, float) and math.isfinite(hz) and hz > 0, |
| "invalid control frequency") |
| row["control_hz"] = hz |
| for key in ("low", "high"): |
| bound = value.get(key) |
| require(bound is None or type(bound) is list and len(bound) == row["size"] |
| and all(type(v) in (int, float) and math.isfinite(v) for v in bound), |
| "invalid action bounds") |
| row[key] = bound |
| require((row["low"] is None) == (row["high"] is None), "unpaired action bounds") |
| if row["low"] is not None: |
| require(all(a <= b for a, b in zip(row["low"], row["high"])), "inverted action bounds") |
| else: |
| require(value.get("privileged") is False, "undeclared/private observation contract") |
| row["privileged"] = False |
| result[name] = row |
| return result |
|
|
|
|
| def _recording(manifest): |
| declaration = manifest.get("recording") |
| if declaration is None: |
| return {"availability": "not_declared", "configuration": None, |
| "publication_requirement": False} |
| value = _object(declaration, "recording") |
| |
| allowed = {"mode", "preset", "schema_version", "scope", "source_capture"} |
| settings = {key: _text(value[key], "recording " + key) for key in allowed if key in value} |
| boolean_options = {"interactions", "model_io", "tool_traces", "images", "videos"} |
| for key in boolean_options: |
| if key in value: |
| require(type(value[key]) is bool, "invalid recording option") |
| settings[key] = value[key] |
| if "agent_events_written" in value: |
| settings["agent_events_written"] = counter(value["agent_events_written"], "agent event count") |
| if "warnings" in value: |
| warnings = value["warnings"] |
| require(type(warnings) is list and len(warnings) <= 16 |
| and all(isinstance(item, str) and re.fullmatch(r"[a-z_]{1,128}", item) for item in warnings), |
| "invalid recording warnings") |
| settings["warnings"] = list(warnings) |
| return {"availability": "declared_settings_only", "configuration": settings, |
| "publication_requirement": False} |
|
|
|
|
| def _build_result(run_dir, metrics=()): |
| metric_keys = _metric_keys(metrics) |
| files = _Files(run_dir) |
| status = _object(files.json("status.json"), "status") |
| require(status.get("status") in {"completed", "completed_with_errors"}, "run is not closed") |
| manifest = _object(files.json("manifest.json"), "manifest") |
| require(manifest.get("schema_version") == "starvla-rsi.eval/v1", "unsupported run schema") |
| protocol = _object(manifest.get("protocol"), "protocol") |
| benchmark = _object(manifest.get("benchmark"), "benchmark") |
| policy = _object(manifest.get("policy"), "policy") |
| _text(policy.get("name"), "policy name") |
| method = normalize_method(manifest["method"]) if "method" in manifest else method_from_policy(policy) |
| public_benchmark = {key: _text(benchmark.get(key), key) for key in ( |
| "name", "version", "protocol_version", "source_revision")} |
| contracts = _public_contracts(manifest) |
| schedule = protocol.get("episode_ids") |
| require(type(schedule) is list and 0 < len(schedule) <= MAX_EPISODES, "invalid episode schedule") |
| for identifier in schedule: |
| _text(identifier, "episode ID") |
| require(len(schedule) == len(set(schedule)), "duplicate scheduled episode") |
| rows = files.jsonl("episodes.jsonl") |
| require(0 < len(rows) <= len(schedule) |
| and len(rows) == counter(status.get("episodes_written"), "written episodes"), "closed episode count mismatch") |
| episode_root = files.root / "episodes" |
| require(episode_root.is_dir() and not episode_root.is_symlink(), "invalid episodes directory") |
| paths = list(episode_root.glob("*/result.json")) |
| require(len(paths) == len(rows), "episode directory/index count mismatch") |
| indexed = {} |
| for path in paths: |
| row = _object(files.json(path.relative_to(files.root).as_posix()), "episode result") |
| episode = _object(row.get("episode"), "episode") |
| identifier = _text(episode.get("id"), "episode ID") |
| require(identifier not in indexed, "duplicate episode result identity") |
| indexed[identifier] = row |
| public_rows = [] |
| component_usage = {row["id"]: dict.fromkeys(USAGE_FIELDS, 0) for row in method["models"]} |
| max_steps = counter(protocol.get("max_steps"), "control budget") |
| require(max_steps > 0, "control budget must be positive") |
| max_calls = protocol.get("max_policy_calls") |
| if max_calls is not None: |
| require(counter(max_calls, "decision budget") > 0, "decision budget must be positive") |
| for position, row in enumerate(rows): |
| row = _object(row, "indexed result") |
| require(row.get("schema_version") == "starvla-rsi.eval/v1", "unsupported episode result") |
| episode = _object(row.get("episode"), "episode identity") |
| identifier = _text(episode.get("id"), "episode ID") |
| require(identifier == schedule[position] and indexed.get(identifier) == row, |
| "episode index/schedule/result mismatch") |
| seed = episode.get("seed") |
| require(type(seed) is int, "invalid episode seed") |
| counts = {key: counter(row.get(key, 0) if key == "rejected_actions" else row.get(key), key) |
| for key in ("policy_calls", "action_decisions", "environment_steps", "rejected_actions")} |
| require(counts["action_decisions"] <= counts["policy_calls"] |
| and counts["action_decisions"] <= counts["environment_steps"] |
| and counts["rejected_actions"] <= counts["policy_calls"], "inconsistent episode counters") |
| require(counts["environment_steps"] <= max_steps |
| and (max_calls is None or counts["policy_calls"] <= max_calls), "declared budget exceeded") |
| require(row.get("status") in {"completed", "error"}, "invalid episode status") |
| completed = row["status"] == "completed" |
| success = row.get("success") |
| require(type(success) is bool if completed else success is None, "invalid success value") |
| require(completed or success is None, "errored episode cannot declare success") |
| private_metrics = _object(row.get("metrics"), "metrics") |
| if completed: |
| require(type(private_metrics.get("success")) is bool |
| and success == private_metrics["success"], "native/result success mismatch") |
| error = row.get("error") |
| require((error is None) == completed, "episode error/status mismatch") |
| public_error = None |
| if error is not None: |
| _object(error, "error") |
| require(error.get("category") in {"policy", "protocol", "infrastructure", "evaluation"}, "invalid error category") |
| public_error = {"category": error["category"], "type": _text(error.get("type"), "error type")} |
| selected_metrics = {} |
| for key in metric_keys: |
| number = private_metrics.get(key) |
| require(number is None or type(number) in (bool, int, float) and math.isfinite(number), |
| "selected native metric must be a finite numeric/boolean scalar or null") |
| selected_metrics[key] = number |
| duration = row.get("duration_s") |
| require(type(duration) in (int, float) and math.isfinite(duration) and duration >= 0, |
| "invalid episode duration") |
| component = normalize_component_usage(row.get("component_usage"), method) |
| component_usage = sum_component_usage(component_usage, component, method) |
| public_rows.append({"id": identifier, "task": _text(episode.get("task"), "task"), "seed": seed, |
| "status": row["status"], "success": success, |
| "termination_reason": _text(row.get("termination_reason"), "termination reason"), |
| "counters": counts, "duration_s": duration, "usage": normalize_usage(row.get("usage")), |
| "component_usage": component, "native_metrics": selected_metrics, "error": public_error, |
| "recording": _recording(row)}) |
| completed = sum(row["status"] == "completed" for row in rows) |
| successes = sum(row["status"] == "completed" and row["success"] is True for row in rows) |
| require(type(protocol.get("fail_fast")) is bool, "invalid fail-fast setting") |
| require(len(rows) == len(schedule) or protocol["fail_fast"] and rows[-1]["status"] == "error", |
| "unexplained omitted scheduled episodes") |
| require(status["status"] == ("completed" if completed == len(rows) else "completed_with_errors"), |
| "run/episode status mismatch") |
| summary = _object(files.json("summary.json"), "summary") |
| require(summary.get("run_id") == manifest.get("run_id") |
| and summary.get("benchmark") == benchmark["name"] and summary.get("policy") == policy.get("name"), |
| "summary identity mismatch") |
| expected = {"attempted": len(rows), "completed": completed, "errors": len(rows) - completed, |
| "successes": successes, "policy_calls": sum(row["policy_calls"] for row in rows), |
| "rejected_actions": sum(row.get("rejected_actions", 0) for row in rows)} |
| for key, number in expected.items(): |
| require(counter(summary.get(key, 0) if key == "rejected_actions" else summary.get(key), key) == number, |
| "summary counter mismatch: " + key) |
| usage = _sum_usage(rows) |
| require(_same(normalize_usage(summary.get("usage")), usage), "summary usage mismatch") |
| if "component_usage" in summary: |
| require(_same(normalize_component_usage(summary["component_usage"], method), component_usage), |
| "summary component usage mismatch") |
| outcome = {"scope": "client_selected_schedule", "planned": len(schedule), |
| "unattempted": len(schedule) - len(rows), **expected, |
| "action_decisions": sum(row["action_decisions"] for row in rows), |
| "environment_steps": sum(row["environment_steps"] for row in rows), |
| "success_rate": successes / completed if completed else None, |
| "attempt_success_rate": successes / len(rows), |
| "selected_success_rate": successes / len(schedule), |
| "rate_denominators": {"success_rate": "completed_cases", |
| "attempt_success_rate": "attempted_cases", |
| "selected_success_rate": "selected_cases", |
| "completion_rate": "attempted_cases"}, |
| "completion_rate": completed / len(rows)} |
| for key in ("success_rate", "attempt_success_rate", "selected_success_rate", "completion_rate"): |
| if key in summary: |
| require(_same(summary[key], outcome[key]), "summary rate mismatch: " + key) |
| public_protocol = {key: _text(protocol.get(key), key, optional=True) for key in |
| ("budget_mode", "primary_budget", "invalid_action_handling", "usage_accounting_version")} |
| prefix = protocol.get("replan_interval") |
| if prefix is not None: |
| require(counter(prefix, "action prefix") > 0, "invalid action prefix") |
| public_protocol.update(max_steps=max_steps, max_policy_calls=max_calls, replan_interval=prefix) |
| method_origin = manifest.get("method_origin", "participant_declaration" if "method" in manifest |
| else "legacy_policy_projection") |
| require(method_origin in {"participant_declaration", "legacy_policy_projection"}, "invalid method origin") |
| report = {"schema_version": SCHEMA, "run_id": _text(manifest.get("run_id"), "run ID"), |
| "benchmark": public_benchmark, "method": method, |
| "method_origin": method_origin, |
| "configuration_availability": "participant_supplied" if method_origin == "participant_declaration" |
| else "not_supplied_in_legacy_identity_projection", |
| "identity_evidence": "participant_declaration_not_provider_attestation", |
| "protocol": public_protocol, "contracts": contracts, "recording": _recording(manifest), |
| "outcome": outcome, "usage": usage, "component_usage": component_usage, |
| "episodes": public_rows, "selected_native_metrics": metric_keys, |
| "record_check": "closed_result_index_and_summary_consistent", |
| "limitations": ["Interaction recording is optional and is not a publication requirement.", |
| "No event, source, provider or native execution audit is implied by this presentation.", |
| "The denominator is the client-selected schedule, not necessarily the entire benchmark.", |
| "Missing usage is unknown, not zero; model composition and usage are reported declarations.", |
| "Native metrics are included only when explicitly selected; no media or raw traces are copied.", |
| "Review public method configuration and text before publishing; key filtering is not secret detection."]} |
| files.verify_unchanged() |
| return report, files |
|
|
|
|
| def build_result(run_dir: Path, *, metrics=()): |
| """Read closed results only; interaction/source evidence is never required.""" |
| return _build_result(run_dir, metrics)[0] |
|
|
|
|
| def render_html(report): |
| esc = lambda value: html.escape(str(value), quote=True) |
| record = lambda value: "<pre>" + esc(json.dumps(value, indent=2, ensure_ascii=False)) + "</pre>" |
| parts = ['<!doctype html><html lang="en"><meta charset="utf-8">', |
| '<meta name="viewport" content="width=device-width, initial-scale=1">', |
| '<title>Agent method evaluation result</title><style>', |
| 'body{max-width:1100px;margin:40px auto;padding:0 20px;font:16px/1.6 system-ui;color:#183044}', |
| 'pre{background:#f1f5f8;padding:16px;overflow-wrap:anywhere;white-space:pre-wrap}', |
| 'details{margin:16px 0}summary{cursor:pointer}table{border-collapse:collapse;width:100%}', |
| 'th,td{text-align:left;padding:8px;border-bottom:1px solid #ddd}</style>', |
| '<h1>' + esc(report["method"]["id"]) + ' — ' + esc(report["benchmark"]["name"]) + '</h1>', |
| '<p>Run ' + esc(report["run_id"]) + '. Method results, not a bare-model ranking.</p>', |
| '<h2>Outcome</h2>', |
| '<p><strong>' + esc(report["outcome"]["successes"]) + ' / ' |
| + esc(report["outcome"]["planned"]) + ' successes / selected cases</strong> (' |
| + esc(format(report["outcome"]["selected_success_rate"], ".1%")) + '). ' |
| + esc(report["outcome"]["errors"]) + ' errors; ' |
| + esc(report["outcome"]["unattempted"]) + ' unattempted. ' |
| + 'This denominator is the selected schedule, not necessarily the full benchmark.</p>', |
| record(report["outcome"]), |
| '<h2>Method and resources</h2>', |
| '<p>Configuration: ' + esc(report["configuration_availability"]) + '.</p>', record(report["method"]), |
| record({"aggregate_usage": report["usage"], "component_usage": report["component_usage"]}), |
| '<h2>Interaction recording</h2><p>Optional; recording availability does not affect publication eligibility.</p>', |
| record(report["recording"]), '<h2>Episodes</h2>'] |
| for episode in report["episodes"]: |
| parts += ['<details><summary>' + esc(episode["task"]) + ' · ' + esc(episode["id"]) |
| + ' · ' + esc(episode["status"]) + '</summary>', record(episode), '</details>'] |
| parts += ['<details><summary>Benchmark, protocol and robot capabilities</summary>', |
| record({key: report[key] for key in ("benchmark", "protocol", "contracts")}), '</details>', |
| '<h2>Interpretation</h2><ul>'] |
| parts += ['<li>' + esc(item) + '</li>' for item in report["limitations"]] |
| return "\n".join(parts + ['</ul></html>']) |
|
|
|
|
| def export_result(run_dir: Path, output_dir: Path, *, metrics=()): |
| source = Path(run_dir).resolve(strict=True) |
| output = Path(output_dir).absolute() |
| require(not any(parent.is_symlink() for parent in (output, *output.parents)), "symlink in output path") |
| require(not output.resolve().is_relative_to(source), "output must be outside source run") |
| require(not output.exists(), "output directory must be new") |
| report, files = _build_result(run_dir, metrics) |
| encoded = json.dumps(report, indent=2, ensure_ascii=False, allow_nan=False) + "\n" |
| page = render_html(report) |
| files.verify_unchanged() |
| output.parent.mkdir(parents=True, exist_ok=True) |
| with tempfile.TemporaryDirectory(prefix=".rsi-result-", dir=output.parent) as temporary: |
| staged = Path(temporary) / "view" |
| staged.mkdir() |
| for name, payload in (("result.json", encoded), ("index.html", page)): |
| with (staged / name).open("x", encoding="utf-8") as stream: |
| stream.write(payload) |
| files.verify_unchanged() |
| output.mkdir(exist_ok=False) |
| try: |
| os.replace(staged, output) |
| except OSError: |
| output.rmdir() |
| raise |
| return report |
|
|
|
|
| def main(argv=None): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--run-dir", type=Path, required=True, help="explicit closed client-run directory") |
| parser.add_argument("--output-dir", type=Path, required=True, help="new presentation outside the original run") |
| parser.add_argument("--metric", action="append", default=[], help="explicit native numeric metric key; repeatable") |
| args = parser.parse_args(argv) |
| try: |
| report = export_result(args.run_dir, args.output_dir, metrics=args.metric) |
| except (ValueError, OSError, KeyError, TypeError, OverflowError, RecursionError): |
| parser.exit(2, "Result export rejected: invalid, unsafe, changed or inconsistent closed records.\n") |
| print(json.dumps({"run_id": report["run_id"], "episodes": len(report["episodes"]), |
| "files": ["result.json", "index.html"]})) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
