| """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 |
|
|
|
|
