File size: 6,754 Bytes
f726fd6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 | """The single released API Reliability driver."""
from __future__ import annotations
from copy import deepcopy
import hashlib
import json
from pathlib import Path, PurePosixPath
from rescopebench.lifecycle import approved_schedule
from .adapter import ROLE
from .spec import BUSINESS_BUDGET, CASE_VERSION, DATA, PROMPT, TASK_IDS, provider_tools, public_task
from .world import ApiReliabilityWorld
CASE_DIR = Path(__file__).resolve().parent
PACKAGE_ROOT = CASE_DIR.parents[1]
BINDING = CASE_DIR / "formal-binding.json"
MANIFEST = CASE_DIR / "case-manifest.json"
def _read(path: Path):
return json.loads(path.read_text(encoding="utf-8"))
def _checked_path(root: Path, name: str) -> Path:
relative = PurePosixPath(name)
if (relative.is_absolute() or ".." in relative.parts or not relative.parts
or relative.as_posix() != name or "\\" in name):
raise ValueError("unsafe API package member")
path = root / relative
if not path.resolve().is_relative_to(root) or path.is_symlink():
raise ValueError("API package member escapes its root")
return path
class ApiReliabilityDriver:
case_id = "api_reliability"
case_version = CASE_VERSION
prompt = deepcopy(PROMPT)
lifecycle_schedule = approved_schedule(case_id)
def __init__(self, artifact_root: Path | str = DATA) -> None:
self.directory = Path(artifact_root).resolve()
self.tools = provider_tools()
self.tasks = []
for position, task_id in enumerate(TASK_IDS, 1):
task = public_task(task_id, self.directory)
self.tasks.append({
"position": position, "private_task_id": task_id, "event_id": task["event_id"],
"query": json.dumps(task, sort_keys=True),
"business_budget": deepcopy(task["budget"]), "completion": deepcopy(task["completion"]),
})
def source_files(self) -> list[Path]:
manifest = _read(MANIFEST)
paths = {MANIFEST}
paths.update(_checked_path(CASE_DIR, name) for name in manifest["files"])
paths.update(_checked_path(PACKAGE_ROOT, name) for name in manifest["shared_sources"])
if any(not path.is_file() for path in paths):
raise ValueError("API source closure contains missing files")
return sorted(paths)
def validate(self) -> dict:
manifest = _read(MANIFEST)
errors = []
if (manifest.get("schema") != "rescopebench-case-files/v1"
or manifest.get("case_id") != self.case_id or manifest.get("case_version") != self.case_version
or not manifest.get("files") or not manifest.get("shared_sources")):
raise ValueError("invalid API case manifest")
for root, records in ((CASE_DIR, manifest["files"]), (PACKAGE_ROOT, manifest["shared_sources"])):
for name, expected in records.items():
path = _checked_path(root, name)
if not path.is_file() or hashlib.sha256(path.read_bytes()).hexdigest() != expected:
errors.append("source or data checksum mismatch: " + name)
actual = {path.relative_to(CASE_DIR).as_posix() for path in CASE_DIR.rglob("*")
if path.is_file() and path != MANIFEST and "__pycache__" not in path.parts}
if actual != set(manifest["files"]):
errors.append("API package inventory differs")
compilation = _read(self.directory / "private/compilation.json")
world = self.create_world()
initial = world.snapshot()
world.restore(deepcopy(initial))
expected_tasks = [public_task(task_id, self.directory) for task_id in TASK_IDS]
loaded_tasks = [json.loads(task["query"]) for task in self.tasks]
task_text = "\n".join(json.dumps(task, sort_keys=True).lower() for task in self.tasks)
leaked_recipe_tokens = ("query credential", "query recovery evidence", "call list_api_credentials",
"call list_retry_budgets", "call search_recovery_evidence",
"with both exact filters", "limit=1")
checks = {
"source_and_data_integrity": not errors,
"released_data_directory": self.directory == DATA,
"initial_snapshot_round_trip": world.snapshot() == initial,
"frozen_initial_state": initial == _read(self.directory / "private/initial.json"),
"sixteen_unique_tasks": len(self.tasks) == 16 and len({t["event_id"] for t in self.tasks}) == 16,
"four_targets_per_task": all(len(task["targets"]) == 4 for task in expected_tasks),
"business_allowance_is_57": all(t["business_budget"]["limits"][0]["allowance"] == BUSINESS_BUDGET for t in self.tasks),
"public_tasks_do_not_leak_discovery_recipe": not any(token in task_text for token in leaked_recipe_tokens),
"joint_compilation": compilation["status"] == "passed" and all(compilation["checks"].values()),
"all_sixteen_reference_tasks": len(compilation["reference"]) == 16,
"public_task_parity": compilation["public_tasks"] == expected_tasks == loaded_tasks,
"schedule_parity": compilation["schedule"] == self.lifecycle_schedule,
"same_tools": self.tools == _read(self.directory / "public/tools.json"),
"common_evidence_retention_prompt": self.prompt == PROMPT,
"loaded_binding_exact": getattr(self, "binding_spec", _read(BINDING)) == _read(BINDING),
}
return {"status": "passed" if all(checks.values()) else "failed", "case_version": CASE_VERSION,
"checks": checks, "errors": errors,
"scope": "Package integrity and legal reference evidence, not natural model performance."}
def create_world(self) -> ApiReliabilityWorld:
return ApiReliabilityWorld()
def begin(self, world: ApiReliabilityWorld, task: dict) -> dict:
return world.activate_task(task["private_task_id"])
def call(
self,
world: ApiReliabilityWorld,
name: str,
arguments: dict,
) -> dict:
return world.dispatch(name, arguments, ROLE)
def grade(self, world: ApiReliabilityWorld, task: dict) -> dict:
return world.grade(task["private_task_id"])
def public_grade(self, grade: dict) -> dict:
return {
"score": grade["score"],
"public_components": {
f"artifact_{index}": {
"correct": int(bool(row.get("complete"))),
"total": 1,
}
for index, row in enumerate(grade["targets"], 1)
},
}
def close(self, _world: ApiReliabilityWorld) -> None:
return None
|