"""Strongly typed records for the question-first evaluator. The v1 evaluator placed executable semantics inside a free-form ``params`` dictionary. V2 makes the normalized predicate, evidence dependencies and answer provenance first-class records. Unknown semantics are valid, but they must be marked ``manual_required`` and can never reach either a deterministic scorer or an implicit VLM fallback. """ from __future__ import annotations import hashlib import json from dataclasses import dataclass, field from typing import Any, Mapping SCHEMA_VERSION = "pvr.question_eval.v2" TERMINAL_EVIDENCE_STATUSES = {"success", "insufficient", "unsupported", "error"} ANSWER_STATUSES = {"pass", "partial", "fail", "uncertain"} ANSWER_MODES = {"deterministic", "deterministic_or_vlm", "vlm_required", "manual_only"} COMPILE_STATUSES = {"executable", "manual_required", "vlm_required"} DECISION_MODES = {"objective", "manual_only"} OBJECTIVE_PREDICATE_KINDS = { "attribute_object_in_region", "change_fraction", "count_in_region", "source_normalized_clearance", "text_match", } def _tuple_strings(value: Any) -> tuple[str, ...]: if isinstance(value, str): return tuple(item.strip() for item in value.split("|") if item.strip()) if isinstance(value, (list, tuple, set)): return tuple(str(item).strip() for item in value if str(item).strip()) return () def _jsonable(value: Any) -> Any: if value.__class__.__module__.startswith("numpy"): if getattr(value, "ndim", 0) == 0: return value.item() # Runtime adapters may carry full masks between DAG nodes. Persist a # stable, compact summary rather than megabytes of pixels; visual mask # artifacts and source call IDs remain separately auditable. return { "array_summary": True, "shape": [int(item) for item in value.shape], "dtype": str(value.dtype), "nonzero": int(value.astype(bool).sum()), } if isinstance(value, tuple): return [_jsonable(item) for item in value] if isinstance(value, list): return [_jsonable(item) for item in value] if isinstance(value, dict): return {str(key): _jsonable(item) for key, item in value.items()} return value def stable_hash(payload: Mapping[str, Any]) -> str: text = json.dumps(_jsonable(dict(payload)), ensure_ascii=False, sort_keys=True, separators=(",", ":")) return hashlib.sha256(text.encode("utf-8")).hexdigest() @dataclass(frozen=True) class QuestionRubric: case_id: str check_id: str question: str pass_criteria: str partial_criteria: str fail_criteria: str role: str dimension: str weight: float hard_fail: bool = False def __post_init__(self) -> None: if not self.case_id or not self.check_id: raise ValueError("question rubric requires case_id and check_id") if not self.question.strip(): raise ValueError(f"question rubric {self.check_id!r} has no question") if self.role not in {"reward", "penalty"}: raise ValueError(f"invalid rubric role: {self.role}") if self.weight < 0: raise ValueError("rubric weight must be non-negative") @classmethod def from_contract_item(cls, case_id: str, item: Mapping[str, Any]) -> "QuestionRubric": role = "penalty" if str(item.get("role", "")).lower() == "penalty" or "max_deduct" in item else "reward" weight_key = "max_deduct" if role == "penalty" else "points" return cls( case_id=case_id, check_id=str(item.get("id") or item.get("check_id") or ""), question=str(item.get("question") or item.get("description") or ""), pass_criteria=str(item.get("pass_criteria") or ""), partial_criteria=str(item.get("partial_criteria") or ""), fail_criteria=str(item.get("fail_criteria") or ""), role=role, dimension=str(item.get("dimension") or ("penalty" if role == "penalty" else "target_completion")), weight=float(item.get(weight_key, item.get("weight", 0.0)) or 0.0), hard_fail=bool(item.get("hard_fail", False)), ) def to_dict(self) -> dict[str, Any]: return _jsonable(self.__dict__) @dataclass(frozen=True) class PredicateSpec: """Finite, executable predicate semantics. ``kind`` belongs to a small registry. ``metric`` names the derived fact consumed by the predicate. Bands are explicit numeric intervals such as ``{"pass": {"max": 0}, "partial": {"min": 1, "max": 2}}``. A semantic VLM predicate has ``deterministic=False`` and no executable bands; its frozen rubric remains the source of truth. """ kind: str metric: str = "" subject_queries: tuple[str, ...] = () region_ids: tuple[str, ...] = () bands: dict[str, dict[str, float | None]] = field(default_factory=dict) parameters: dict[str, Any] = field(default_factory=dict) deterministic: bool = False source_rule_type: str = "" def __post_init__(self) -> None: if not self.kind: raise ValueError("predicate kind is required") if self.deterministic: if not self.metric: raise ValueError("deterministic predicate requires a metric") if "pass" not in self.bands or "fail" not in self.bands: raise ValueError("deterministic predicate requires pass and fail bands") for status, band in self.bands.items(): if status not in {"pass", "partial", "fail"}: raise ValueError(f"invalid predicate band: {status}") low, high = band.get("min"), band.get("max") if low is not None and high is not None and float(low) > float(high): raise ValueError(f"invalid band interval for {status}") def to_dict(self) -> dict[str, Any]: return _jsonable(self.__dict__) @dataclass(frozen=True) class DecisionSpec: """Contract-owned instructions for turning evidence into one answer. Free-form ``decision_rule.type`` names describe intent but are not an executable interface. This finite record either names a validated objective predicate or explicitly sends the question to human review. """ mode: str predicate: PredicateSpec subject_region_ids: tuple[str, ...] = () target_region_ids: tuple[str, ...] = () required_tools: tuple[str, ...] = () manual_reasons: tuple[str, ...] = () schema_version: str = "pvr.decision_spec.v1" def __post_init__(self) -> None: if self.mode not in DECISION_MODES: raise ValueError(f"invalid decision mode: {self.mode}") if self.mode == "objective" and not self.predicate.deterministic: raise ValueError("objective decision spec requires deterministic predicate") if self.mode == "objective" and self.predicate.kind not in OBJECTIVE_PREDICATE_KINDS: raise ValueError(f"unsupported objective predicate kind: {self.predicate.kind}") if self.mode == "manual_only" and self.predicate.deterministic: raise ValueError("manual-only decision spec cannot carry deterministic predicate") overlap = set(self.subject_region_ids) & set(self.target_region_ids) if overlap: raise ValueError(f"subject and target regions must be disjoint: {sorted(overlap)}") if self.mode == "objective" and any("vlm" in tool.lower() for tool in self.required_tools): raise ValueError("objective decision spec cannot require a VLM tool") if self.mode == "objective" and set(self.predicate.region_ids) != set(self.target_region_ids): raise ValueError("objective predicate regions must exactly match target regions") @classmethod def from_mapping(cls, value: Mapping[str, Any]) -> "DecisionSpec": predicate_value = value.get("predicate") if isinstance(value.get("predicate"), Mapping) else {} evidence = value.get("evidence") if isinstance(value.get("evidence"), Mapping) else {} predicate = PredicateSpec( kind=str(predicate_value.get("kind") or "manual_review"), metric=str(predicate_value.get("metric") or ""), subject_queries=_tuple_strings(predicate_value.get("subject_queries")), region_ids=_tuple_strings(predicate_value.get("region_ids") or evidence.get("target_region_ids")), bands={ str(status): {str(key): item for key, item in dict(band).items()} for status, band in dict(predicate_value.get("bands") or {}).items() if isinstance(band, Mapping) }, parameters=dict(predicate_value.get("parameters") or {}), deterministic=bool(predicate_value.get("deterministic", value.get("mode") == "objective")), source_rule_type=str(predicate_value.get("source_rule_type") or "decision_spec_v1"), ) return cls( mode=str(value.get("mode") or "manual_only"), predicate=predicate, subject_region_ids=_tuple_strings(evidence.get("subject_region_ids")), target_region_ids=_tuple_strings(evidence.get("target_region_ids") or predicate.region_ids), required_tools=_tuple_strings(evidence.get("required_tools")), manual_reasons=_tuple_strings(value.get("manual_reasons")), schema_version=str(value.get("schema_version") or "pvr.decision_spec.v1"), ) def to_dict(self) -> dict[str, Any]: return { "schema_version": self.schema_version, "mode": self.mode, "predicate": self.predicate.to_dict(), "evidence": { "subject_region_ids": list(self.subject_region_ids), "target_region_ids": list(self.target_region_ids), "required_tools": list(self.required_tools), }, "manual_reasons": list(self.manual_reasons), } @dataclass(frozen=True) class EvidenceNodeSpec: node_id: str operation: str tool: str image_roles: tuple[str, ...] depends_on: tuple[str, ...] = () region_ids: tuple[str, ...] = () inputs: tuple[str, ...] = () required: bool = True parameters: dict[str, Any] = field(default_factory=dict) def __post_init__(self) -> None: if not self.node_id or not self.operation or not self.tool: raise ValueError("evidence node requires id, operation and tool") if self.node_id in self.depends_on: raise ValueError(f"evidence node {self.node_id!r} depends on itself") def to_dict(self) -> dict[str, Any]: return _jsonable(self.__dict__) @dataclass(frozen=True) class EvalProcedure: rubric: QuestionRubric predicate: PredicateSpec nodes: tuple[EvidenceNodeSpec, ...] answer_mode: str compile_status: str compile_reasons: tuple[str, ...] = () gt_policy: str = "not_allowed" source_decision_rule: dict[str, Any] = field(default_factory=dict) decision_spec: DecisionSpec | None = None schema_version: str = SCHEMA_VERSION def __post_init__(self) -> None: if self.answer_mode not in ANSWER_MODES: raise ValueError(f"invalid answer mode: {self.answer_mode}") if self.compile_status not in COMPILE_STATUSES: raise ValueError(f"invalid compile status: {self.compile_status}") node_ids = [node.node_id for node in self.nodes] if len(node_ids) != len(set(node_ids)): raise ValueError("duplicate evidence node ids") known = set(node_ids) for node in self.nodes: missing = set(node.depends_on) - known if missing: raise ValueError(f"node {node.node_id!r} has unknown dependencies: {sorted(missing)}") if self.predicate.deterministic and self.answer_mode == "vlm_required": raise ValueError("deterministic predicate cannot require VLM-only answering") if self.answer_mode == "manual_only" and self.compile_status != "manual_required": raise ValueError("manual-only answer mode requires manual_required compile status") if self.answer_mode == "manual_only" and self.predicate.deterministic: raise ValueError("manual-only procedure cannot carry deterministic predicate") @property def procedure_hash(self) -> str: return stable_hash(self.to_dict(include_hash=False)) def to_dict(self, *, include_hash: bool = True) -> dict[str, Any]: payload = { "schema_version": self.schema_version, "rubric": self.rubric.to_dict(), "predicate": self.predicate.to_dict(), "nodes": [node.to_dict() for node in self.nodes], "answer_mode": self.answer_mode, "compile_status": self.compile_status, "compile_reasons": list(self.compile_reasons), "gt_policy": self.gt_policy, "source_decision_rule": _jsonable(self.source_decision_rule), "decision_spec": self.decision_spec.to_dict() if self.decision_spec is not None else None, } if include_hash: payload["procedure_hash"] = stable_hash(payload) return payload @dataclass(frozen=True) class QuestionSpec(EvalProcedure): """Frozen, executable specification for one audited atomic question. ``EvalProcedure`` remains as the compatibility/base type used by DAG utilities; compilers emit this more explicit public type. """ pass @dataclass(frozen=True) class EvidenceNodeResult: node_id: str status: str call_ids: tuple[str, ...] = () facts: dict[str, Any] = field(default_factory=dict) artifacts: tuple[dict[str, Any], ...] = () limitations: tuple[str, ...] = () def __post_init__(self) -> None: if self.status not in TERMINAL_EVIDENCE_STATUSES: raise ValueError(f"invalid evidence status: {self.status}") if self.status == "success" and not self.call_ids and self.node_id not in {"derive_facts", "render_overlay"}: raise ValueError(f"successful evidence node {self.node_id!r} requires provenance call_ids") def to_dict(self) -> dict[str, Any]: return _jsonable(self.__dict__) @dataclass(frozen=True) class EvidencePacket: case_id: str check_id: str procedure_hash: str nodes: tuple[EvidenceNodeResult, ...] derived_facts: dict[str, Any] visual_artifacts: tuple[dict[str, Any], ...] = () status: str = "insufficient" reasons: tuple[str, ...] = () schema_version: str = "pvr.evidence_packet.v2" def __post_init__(self) -> None: if self.status not in TERMINAL_EVIDENCE_STATUSES: raise ValueError(f"invalid evidence packet status: {self.status}") ids = [node.node_id for node in self.nodes] if len(ids) != len(set(ids)): raise ValueError("duplicate node results in evidence packet") @property def successful_call_ids(self) -> tuple[str, ...]: values = {call_id for node in self.nodes if node.status == "success" for call_id in node.call_ids if call_id} return tuple(sorted(values)) @property def packet_hash(self) -> str: return stable_hash(self.to_dict(include_hash=False)) def to_dict(self, *, include_hash: bool = True) -> dict[str, Any]: payload = { "schema_version": self.schema_version, "case_id": self.case_id, "check_id": self.check_id, "procedure_hash": self.procedure_hash, "nodes": [node.to_dict() for node in self.nodes], "derived_facts": _jsonable(self.derived_facts), "visual_artifacts": [_jsonable(item) for item in self.visual_artifacts], "status": self.status, "reasons": list(self.reasons), } if include_hash: payload["packet_hash"] = stable_hash(payload) return payload @dataclass(frozen=True) class AnswerRecord: case_id: str check_id: str status: str score: float confidence: float answer_source: str evidence_packet_hash: str cited_call_ids: tuple[str, ...] rationale: str formal_eligible: bool reasons: tuple[str, ...] = () schema_version: str = "pvr.answer_record.v2" def __post_init__(self) -> None: if self.status not in ANSWER_STATUSES: raise ValueError(f"invalid answer status: {self.status}") if not 0.0 <= self.score <= 1.0 or not 0.0 <= self.confidence <= 1.0: raise ValueError("answer score and confidence must be in [0, 1]") if self.formal_eligible and (self.status == "uncertain" or not self.cited_call_ids): raise ValueError("formal answer requires a resolved status and cited tool calls") def to_dict(self) -> dict[str, Any]: return _jsonable(self.__dict__)