"""Persistent lifecycle runtime for the API Reliability task stream.""" from __future__ import annotations from copy import deepcopy import hashlib import json from typing import Any from rescopebench.cases.api_reliability.adapter import ( PUBLIC_TOOLS, REFERENCE_NOW, RETRYABLE_STATUSES, ROLE, ApiReliabilityAdapter, ) from .spec import ( CHANGED_RULE_IDS, DRIFTED_RULES, DRIFT_EVENT_ID, INITIAL_BUDGET, OPERATION_BY_CLASS, PRE_RULES, RULE_SCHEDULE, STRUCTURE_BY_ID, STRUCTURE_CLUSTERS, STRUCTURE_SCHEDULE, TASK_IDS, _bucket_id, stream_targets, ) STREAM_ALLOWANCE = INITIAL_BUDGET SNAPSHOT_SCHEMA = "rescopebench-api-reliability-stream-snapshot/v1" def _canonical(value: Any) -> str: return json.dumps(value, ensure_ascii=True, sort_keys=True, separators=(",", ":")) def _opaque(prefix: str, *parts: Any, length: int = 12) -> str: payload = "|".join(str(part) for part in parts) digest = hashlib.sha256(f"api-reliability-stream|{payload}".encode("utf-8")).hexdigest() return f"{prefix}-{digest[:length]}" def _rule_rows(*, drifted: bool) -> dict[str, dict[str, str]]: return deepcopy(DRIFTED_RULES if drifted else PRE_RULES) def _status_for_signal(signal: str) -> tuple[str, str]: return { "queued_replay": ("queued", "REPLAY_QUEUED"), "provider_5xx": ("transient_error", "HTTP_503"), "timeout": ("timeout", "TIMEOUT"), "rate_limit": ("rate_limited", "HTTP_429"), }[signal] class _MemoryDatabase: def __init__(self, data: dict[str, list[dict[str, Any]]]) -> None: self._data = deepcopy(data) def _flush(self, entity_type: str) -> None: del entity_type class _MemoryManager: def __init__(self, data: dict[str, list[dict[str, Any]]]) -> None: self.db = _MemoryDatabase(data) self._counters: dict[str, int] = {} def snapshot(self) -> dict[str, Any]: return {"database": deepcopy(self.db._data), "counters": deepcopy(self._counters)} def query_entities(self, entity_type: str, predicate: Any) -> list[dict[str, Any]]: return [deepcopy(row) for row in self.db._data.get(entity_type, []) if predicate(row)] def get_entity(self, entity_type: str, entity_id: str, id_field: str = "id") -> dict[str, Any] | None: for row in self.db._data.get(entity_type, []): if row.get(id_field) == entity_id: return deepcopy(row) return None def list_entities(self, entity_type: str) -> list[dict[str, Any]]: return deepcopy(self.db._data.get(entity_type, [])) def add_entity(self, entity_type: str, entity: dict[str, Any], id_field: str = "id") -> dict[str, Any]: rows = self.db._data.setdefault(entity_type, []) key = entity.get(id_field) for index, row in enumerate(rows): if row.get(id_field) == key: rows[index] = deepcopy(entity) return deepcopy(entity) rows.append(deepcopy(entity)) return deepcopy(entity) class _MemoryServer: def __init__(self, manager: _MemoryManager) -> None: self.manager = manager @staticmethod def _success(tool: str, data: dict[str, Any], message: str) -> dict[str, Any]: return { "type": "tool_result", "tool": tool, "content": {"status": "success", "data": data, "message": message}, } @staticmethod def _page(rows: list[dict[str, Any]], arguments: dict[str, Any]) -> dict[str, Any]: offset = int(arguments.get("offset", 0)) limit = int(arguments.get("limit", 25)) return { "total_count": len(rows), "offset": offset, "limit": limit, "items": deepcopy(rows[offset : offset + limit]), } def cleanup_runtime(self) -> None: return None def call_tool(self, tool: str, state_manager: Any = None, **arguments: Any) -> dict[str, Any]: manager = state_manager or self.manager if tool == "list_service_integrations": rows = manager.list_entities("service_integration") if arguments.get("provider_type"): rows = [row for row in rows if row.get("provider_type") == arguments["provider_type"]] if arguments.get("status"): rows = [row for row in rows if row.get("status") == arguments["status"]] return self._success(tool, self._page(rows, arguments), "Integrations listed") if tool == "list_api_credentials": rows = manager.list_entities("api_credential") if arguments.get("integration_id"): rows = [row for row in rows if row.get("integration_id") == arguments["integration_id"]] if arguments.get("status"): rows = [row for row in rows if row.get("status") == arguments["status"]] if arguments.get("scope_contains"): rows = [row for row in rows if arguments["scope_contains"] in (row.get("scope") or [])] return self._success(tool, self._page(rows, arguments), "Credentials listed") if tool == "list_retry_budgets": rows = manager.list_entities("retry_budget") if arguments.get("integration_id"): rows = [row for row in rows if row.get("integration_id") == arguments["integration_id"]] if arguments.get("status"): rows = [row for row in rows if row.get("status") == arguments["status"]] if arguments.get("window_minutes"): rows = [row for row in rows if row.get("window_minutes") == arguments["window_minutes"]] return self._success(tool, self._page(rows, arguments), "Retry budgets listed") if tool == "inspect_rate_limit_status": rows = manager.query_entities( "rate_limit_bucket", lambda row: row.get("integration_id") == arguments["integration_id"] and (not arguments.get("operation") or row.get("operation") == arguments["operation"]), ) return self._success(tool, {"buckets": rows, "requested_units": arguments.get("requested_units", 1)}, "Rate capacity inspected") if tool == "list_fault_policies": rows = manager.list_entities("fault_policy") if arguments.get("integration_id"): rows = [row for row in rows if row.get("integration_id") == arguments["integration_id"]] if "enabled" in arguments: rows = [row for row in rows if row.get("enabled") is arguments["enabled"]] if arguments.get("operation"): rows = [row for row in rows if row.get("operation") == arguments["operation"]] return self._success(tool, self._page(rows, arguments), "Fault policies listed") if tool == "search_audit_events": rows = manager.list_entities("audit_event") if arguments.get("integration_id"): rows = [row for row in rows if row.get("integration_id") == arguments["integration_id"]] if arguments.get("related_call_id"): rows = [row for row in rows if row.get("related_call_id") == arguments["related_call_id"]] return self._success(tool, self._page(rows, arguments), "Audit events listed") if tool == "execute_api_call": digest = hashlib.sha256( _canonical( [ arguments["integration_id"], arguments["operation"], arguments["request_fingerprint"], arguments["idempotency_key"], ] ).encode("utf-8") ).hexdigest()[:12] call_id = f"direct-{digest}" manager.add_entity( "api_call_attempt", { "call_id": call_id, "integration_id": arguments["integration_id"], "credential_id": arguments["credential_id"], "operation": arguments["operation"], "request_hash": arguments["request_fingerprint"], "status": "success", "retry_attempt": 0, "max_retry_attempts": 0, "side_effect_committed": True, "created_at": REFERENCE_NOW, "updated_at": REFERENCE_NOW, }, id_field="call_id", ) manager.add_entity( "idempotency_key", { "idempotency_id": f"idem-{digest}", "integration_id": arguments["integration_id"], "operation": arguments["operation"], "key": arguments["idempotency_key"], "request_fingerprint": arguments["request_fingerprint"], "status": "consumed", "associated_call_id": call_id, }, id_field="idempotency_id", ) return self._success(tool, {"call_id": call_id, "status": "success", "side_effect_committed": True}, "Provider call executed") raise ValueError(f"unsupported in-memory tool: {tool}") def _base_entities() -> dict[str, list[dict[str, Any]]]: data: dict[str, list[dict[str, Any]]] = { "service_integration": [], "api_credential": [], "retry_budget": [], "rate_limit_bucket": [], "fault_policy": [], "api_call_attempt": [], "idempotency_key": [], "audit_event": [], "incident_window": [], } for index, structure in enumerate(STRUCTURE_CLUSTERS, 1): data["service_integration"].append( { "integration_id": structure["integration_id"], "name": structure["integration_name"], "provider_type": "external_api", "status": "active", "created_at": REFERENCE_NOW, "updated_at": REFERENCE_NOW, } ) data["api_credential"].append( { "credential_id": structure["credential_id"], "integration_id": structure["integration_id"], "name": f"Scoped Credential {index}", "status": "active", "scope": list(OPERATION_BY_CLASS.values()), "created_at": REFERENCE_NOW, "updated_at": REFERENCE_NOW, } ) data["retry_budget"].append( { "budget_id": structure["retry_budget_id"], "integration_id": structure["integration_id"], "window_minutes": 60, "status": "open", "max_attempts": 64, "used_attempts": 0, "reserved_attempts": 0, "created_at": REFERENCE_NOW, "updated_at": REFERENCE_NOW, } ) for operation in OPERATION_BY_CLASS.values(): data["rate_limit_bucket"].append( { "bucket_id": _bucket_id(structure["atom_id"], operation), "integration_id": structure["integration_id"], "operation": operation, "status": "healthy", "limit": 64, "remaining": 64, "created_at": REFERENCE_NOW, "updated_at": REFERENCE_NOW, } ) return data def _task_entities(task_id: str) -> dict[str, list[dict[str, Any]]]: data = {"api_call_attempt": [], "fault_policy": []} for target in stream_targets(task_id): status, error_code = _status_for_signal(target["failure_signal"]) data["api_call_attempt"].append( { "call_id": target["call_id"], "integration_id": target["integration_id"], "operation": target["operation"], "status": status, "http_status": 429 if error_code == "HTTP_429" else 503 if error_code == "HTTP_503" else 504 if error_code == "TIMEOUT" else None, "error_code": error_code, "retry_attempt": 0, "max_retry_attempts": 3, "request_hash": _opaque("request", task_id, target["slot"]), "side_effect_committed": False, "created_at": REFERENCE_NOW, "updated_at": REFERENCE_NOW, } ) data["fault_policy"].append( { "fault_policy_id": target["fault_policy_id"], "integration_id": target["integration_id"], "operation": target["operation"], "failure_signal": target["failure_signal"], "enabled": True, "created_at": REFERENCE_NOW, "updated_at": REFERENCE_NOW, } ) return data class PersistentApiReliabilityAdapter(ApiReliabilityAdapter): """In-memory persistent recovery world with sequential task activation.""" def __init__(self, budget: int = STREAM_ALLOWANCE) -> None: self.manager = _MemoryManager(_base_entities()) self.server = _MemoryServer(self.manager) self.initial_budget = int(budget) self.remaining = int(budget) self.receipts: list[dict[str, Any]] = [] self.applied_boundary_events: set[str] = set() self.active_task_id: str | None = None self._policy_version = "recovery-policy-v1" self._activated_tasks: list[str] = [] self._task_targets: list[dict[str, Any]] = [] self._active_receipt_start = 0 @property def activated_tasks(self) -> tuple[str, ...]: return tuple(self._activated_tasks) @property def current_rules(self) -> dict[str, dict[str, str]]: return _rule_rows(drifted=self._policy_version == "recovery-policy-v2") def required_profile(self, source: dict[str, Any]) -> str: signal = source.get("failure_signal") operation_class = source.get("operation_class") if not signal or not operation_class: status = str(source.get("status") or "") error = str(source.get("error_code") or "") if status == "queued" or error == "REPLAY_QUEUED": signal = "queued_replay" elif status == "rate_limited" or error == "HTTP_429": signal = "rate_limit" elif status == "timeout" or error in {"TIMEOUT", "HTTP_504"}: signal = "timeout" else: signal = "provider_5xx" operation_class = next( key for key, value in OPERATION_BY_CLASS.items() if value == source.get("operation") ) return next( row["recovery_profile_id"] for row in self.current_rules.values() if row["failure_signal"] == signal and row["operation_class"] == operation_class ) def _retry_guard(self, arguments: dict[str, Any]) -> tuple[dict[str, Any] | None, dict[str, Any] | None]: source = self.manager.get_entity("api_call_attempt", arguments["call_id"], id_field="call_id") if source is None: return None, self._error("retry_api_call", "CALL_NOT_FOUND", "source call does not exist") if source.get("status") not in RETRYABLE_STATUSES: return None, self._error("retry_api_call", "CALL_NOT_RETRYABLE", "source call status is not retryable") if int(source.get("retry_attempt") or 0) >= int(source.get("max_retry_attempts") or 0): return None, self._error("retry_api_call", "RETRY_LIMIT_REACHED", "source call has no retry attempts remaining") prior = self.manager.query_entities( "api_call_attempt", lambda row: row.get("duplicate_of_call_id") == source.get("call_id") and row.get("side_effect_committed") is True, ) if prior: prior.sort(key=lambda row: row.get("call_id") or "") return source, self._success( "retry_api_call", { "source_call_id": source["call_id"], "retry_call_id": prior[0]["call_id"], "status": prior[0].get("status"), "side_effect_committed": True, "idempotent_replay": True, }, "Existing committed recovery returned without another provider call", ) if arguments["recovery_profile_id"] != self.required_profile(source): return None, self._error( "retry_api_call", "RECOVERY_PROFILE_MISMATCH", "the selected recovery profile is not valid for the observed failure and operation class", ) credential = self.manager.get_entity("api_credential", arguments["credential_id"], id_field="credential_id") if credential is None: return None, self._error("retry_api_call", "CREDENTIAL_NOT_FOUND", "credential does not exist") if credential.get("integration_id") != source.get("integration_id"): return None, self._error("retry_api_call", "ENTITY_SCOPE_MISMATCH", "credential belongs to another integration") if credential.get("status") not in {"active", "rotating"}: return None, self._error("retry_api_call", "CREDENTIAL_NOT_USABLE", "credential is not currently usable") if source.get("operation") not in (credential.get("scope") or []): return None, self._error("retry_api_call", "SCOPE_NOT_ALLOWED", "credential scope excludes the source operation") budget = self.manager.get_entity("retry_budget", arguments["retry_budget_id"], id_field="budget_id") if budget is None: return None, self._error("retry_api_call", "BUDGET_NOT_FOUND", "retry budget does not exist") if budget.get("integration_id") != source.get("integration_id"): return None, self._error("retry_api_call", "ENTITY_SCOPE_MISMATCH", "retry budget belongs to another integration") available = int(budget.get("max_attempts") or 0) - int(budget.get("used_attempts") or 0) - int(budget.get("reserved_attempts") or 0) if budget.get("status") != "open" or available < 1: return None, self._error("retry_api_call", "RETRY_BUDGET_EXHAUSTED", "retry budget lacks capacity") bucket = self.manager.get_entity("rate_limit_bucket", arguments["rate_limit_bucket_id"], id_field="bucket_id") if bucket is None: return None, self._error("retry_api_call", "RATE_BUCKET_NOT_FOUND", "rate bucket does not exist") if bucket.get("integration_id") != source.get("integration_id") or bucket.get("operation") != source.get("operation"): return None, self._error("retry_api_call", "ENTITY_SCOPE_MISMATCH", "rate bucket does not match source integration and operation") if bucket.get("status") == "disabled" or int(bucket.get("remaining") or 0) < 1: return None, self._error("retry_api_call", "RATE_LIMIT_EXCEEDED", "rate bucket lacks capacity") return source, None def _search_recovery_evidence(self, arguments: dict[str, Any]) -> dict[str, Any]: rows = list(self.current_rules.values()) if arguments.get("failure_signal"): rows = [row for row in rows if row["failure_signal"] == arguments["failure_signal"]] if arguments.get("operation_class"): rows = [row for row in rows if row["operation_class"] == arguments["operation_class"]] offset = int(arguments.get("offset", 0)) limit = int(arguments.get("limit", 16)) return self._success( "search_recovery_evidence", {"total_count": len(rows), "offset": offset, "limit": limit, "evidence": deepcopy(rows[offset : offset + limit])}, "Archived recovery evidence searched", ) def apply_recovery_policy_drift(self, event_id: str = DRIFT_EVENT_ID) -> dict[str, Any]: if event_id in self.applied_boundary_events: return {"status": "success", "event_id": event_id, "idempotent": True} self._policy_version = "recovery-policy-v2" self.applied_boundary_events.add(event_id) return {"status": "success", "event_id": event_id, "idempotent": False} def activate_task(self, task_id: str, allowance: int = STREAM_ALLOWANCE) -> dict[str, Any]: if task_id not in TASK_IDS: raise ValueError(f"unknown stream task: {task_id}") expected = TASK_IDS[len(self._activated_tasks)] if len(self._activated_tasks) < len(TASK_IDS) else None if task_id != expected: raise ValueError(f"expected {expected}, got {task_id}") boundary = self.apply_recovery_policy_drift() if task_id == "T09" else None for entity_type, rows in _task_entities(task_id).items(): id_field = "call_id" if entity_type == "api_call_attempt" else "fault_policy_id" for row in rows: self.manager.add_entity(entity_type, row, id_field=id_field) self.active_task_id = task_id self._task_targets = [deepcopy(row) for row in stream_targets(task_id)] self.initial_budget = int(allowance) self.remaining = int(allowance) self._active_receipt_start = len(self.receipts) self._activated_tasks.append(task_id) return { "status": "success", "task_id": task_id, "world_reset": False, "budget_reset": True, "boundary_event_applied": boundary is not None and not boundary["idempotent"], "entry_business_hash": self.business_hash(), "entry_lineage_hash": self.lineage_hash(), } def current_episode_events(self) -> list[dict[str, Any]]: return deepcopy(self.receipts[self._active_receipt_start :]) def grade(self, task_id: str | None = None) -> dict[str, Any]: active = task_id or self.active_task_id if active != self.active_task_id or active not in TASK_IDS: raise ValueError("only the active stream task can be graded") grade_targets = [] for target in self._task_targets: row = deepcopy(target) row["recovery_profile_id"] = self.current_rules[target["rule_atom"]]["recovery_profile_id"] grade_targets.append(row) grade = self.grade_targets(grade_targets) grade.update({"task_id": active, "remaining_budget": self.remaining}) return grade def business_hash(self) -> str: payload = {"database": self.manager.snapshot()["database"], "policy_version": self._policy_version} return hashlib.sha256(_canonical(payload).encode("utf-8")).hexdigest() def lineage_hash(self) -> str: return hashlib.sha256(_canonical(self.snapshot()).encode("utf-8")).hexdigest() def snapshot(self) -> dict[str, Any]: return { "schema": SNAPSHOT_SCHEMA, "raw": self.manager.snapshot(), "remaining": self.remaining, "initial_budget": self.initial_budget, "receipts": deepcopy(self.receipts), "applied_boundary_events": sorted(self.applied_boundary_events), "active_task_id": self.active_task_id, "policy_version": self._policy_version, "activated_tasks": list(self._activated_tasks), "task_targets": deepcopy(self._task_targets), "active_receipt_start": self._active_receipt_start, } def restore(self, snapshot: dict[str, Any]) -> None: if snapshot.get("schema") != SNAPSHOT_SCHEMA: raise ValueError("unsupported persistent stream snapshot schema") self._restore_database(snapshot["raw"]["database"], snapshot["raw"].get("counters", {})) self.remaining = int(snapshot["remaining"]) self.initial_budget = int(snapshot.get("initial_budget", STREAM_ALLOWANCE)) self.receipts = deepcopy(snapshot["receipts"]) self.applied_boundary_events = set(snapshot.get("applied_boundary_events", [])) self.active_task_id = snapshot.get("active_task_id") self._policy_version = str(snapshot.get("policy_version") or "recovery-policy-v1") self._activated_tasks = list(snapshot.get("activated_tasks") or []) self._task_targets = deepcopy(snapshot.get("task_targets") or []) self._active_receipt_start = int(snapshot.get("active_receipt_start") or 0) __all__ = [ "CHANGED_RULE_IDS", "DRIFTED_RULES", "DRIFT_EVENT_ID", "OPERATION_BY_CLASS", "PRE_RULES", "RULE_SCHEDULE", "STREAM_ALLOWANCE", "STRUCTURE_CLUSTERS", "STRUCTURE_SCHEDULE", "TASK_IDS", "PersistentApiReliabilityAdapter", "stream_targets", ]