penfever's picture
Release native-format structure-closure validation cohort
44353e7 verified
Raw History Blame Contribute Delete
6.39 kB
# Copyright The Marin Authors
# SPDX-License-Identifier: Apache-2.0
"""Content-preserving scoring for explicitly required structure completion."""
import json
from dataclasses import dataclass
from enum import StrEnum
from rolloutengine.structure_closure import (
ClosureState,
PrefixStatus,
delimited_json_closure_state,
json_closure_state,
paired_marker_closure_state,
required_code_fence_state,
)
from rolloutengine.tool_protocol import JSON_WHITESPACE, THINK_CLOSE, THINK_OPEN, TOOL_CLOSE, TOOL_OPEN
SNOWBALL_TURN_END_MARKERS = ("<|eot_id|>", "<|end_of_text|>")
CLOSURE_REGION_SCORER = "closure_region_v1"
def closure_response_content(text: str, *, stop_reason: str) -> str:
"""Remove one terminal Snowball control marker from a normally stopped turn.
Interior markers, repeated terminal markers, and truncated generations remain
subject to structural validation. Tool and reasoning closers are content.
"""
if stop_reason == "stop":
for marker in SNOWBALL_TURN_END_MARKERS:
if text.endswith(marker):
return text[: -len(marker)]
return text
class ClosureFormat(StrEnum):
"""Supported wire formats; tool and reasoning use Hermes and Snowball markers."""
JSON = "json"
TOOL = "tool"
REASONING = "reasoning"
CODE_FENCE = "code_fence"
class ContinuationOutcome(StrEnum):
REFERENCE_COMPLETED = "reference_completed"
REFERENCE_PREFIX_CLOSED_EARLY = "reference_prefix_closed_early"
OTHER_CONTENT_CHANGE = "other_content_change"
UNCLOSED_OR_INVALID = "unclosed_or_invalid"
@dataclass(frozen=True)
class ClosureScore:
syntax_complete: bool
content_preserved: bool
success: bool
@dataclass(frozen=True)
class ClosureRegionScore:
syntax_complete: bool
content_preserved: bool
success: bool
trailing_content: bool
whole_response_success: bool
def closure_state(text: str, structure_format: ClosureFormat) -> ClosureState:
if structure_format == ClosureFormat.JSON:
return json_closure_state(text)
if structure_format == ClosureFormat.TOOL:
return delimited_json_closure_state(text, opener=TOOL_OPEN, closer=TOOL_CLOSE)
if structure_format == ClosureFormat.REASONING:
return paired_marker_closure_state(text, opener=THINK_OPEN, closer=THINK_CLOSE)
if structure_format == ClosureFormat.CODE_FENCE:
return required_code_fence_state(text)
raise ValueError(f"Unsupported closure format: {structure_format}")
def _json_content(text: str, structure_format: ClosureFormat) -> str:
if structure_format == ClosureFormat.TOOL:
text = text[len(TOOL_OPEN) :].rstrip(JSON_WHITESPACE)[: -len(TOOL_CLOSE)]
# Canonical serialization ignores object order and whitespace, but preserves
# distinctions such as true versus 1 that Python container equality loses.
return json.dumps(json.loads(text), sort_keys=True, ensure_ascii=True, allow_nan=False)
def score_closure(text: str, expected: str, structure_format: ClosureFormat) -> ClosureScore:
"""Check syntax and known content; never infer what unfinished content meant.
JSON permits key-order and whitespace changes. Numeric spellings canonicalize
through Python's JSON decoder; booleans remain distinct from numbers. Opaque
reasoning and fence content must match except for trailing whitespace.
"""
complete = closure_state(text, structure_format).status == PrefixStatus.COMPLETE
if not complete:
return ClosureScore(False, False, False)
if structure_format in (ClosureFormat.JSON, ClosureFormat.TOOL):
reference = _json_content(expected, structure_format)
try:
candidate = _json_content(text, structure_format)
except ValueError:
# A syntactically valid exponent can overflow the JSON decoder's
# float representation. It cannot preserve a finite reference value.
return ClosureScore(True, False, False)
preserved = candidate == reference
else:
preserved = text.rstrip(JSON_WHITESPACE) == expected.rstrip(JSON_WHITESPACE)
return ClosureScore(True, preserved, preserved)
def score_closure_region(text: str, expected: str, structure_format: ClosureFormat) -> ClosureRegionScore:
"""Score the first outer structure; report output after its boundary separately.
Text includes the supplied structure prefix and generated continuation.
Never skip illegal leading syntax to search for a later valid structure.
Expected content still rejects premature completion of continue controls.
"""
state = closure_state(text, structure_format)
if state.completion_offset is None:
return ClosureRegionScore(False, False, False, False, False)
score = score_closure(text[: state.completion_offset], expected, structure_format)
trailing = bool(text[state.completion_offset :].strip(JSON_WHITESPACE))
return ClosureRegionScore(
score.syntax_complete, score.content_preserved, score.success, trailing, score.success and not trailing
)
def continuation_outcome(text: str, expected: str, structure_format: ClosureFormat) -> ContinuationOutcome:
"""Identify closing-only truncation of a known reference, without inferring intent.
Early closure requires an exact strict reference prefix followed only by a verified
syntactic repair. Other content changes include ambiguous truncations with
spelling or whitespace changes; this is a conservative diagnostic, not a
complete detector of semantic premature closure. Trailing output is ignored.
"""
state = closure_state(text, structure_format)
if state.completion_offset is None:
return ContinuationOutcome.UNCLOSED_OR_INVALID
region = text[: state.completion_offset]
score = score_closure(region, expected, structure_format)
if score.content_preserved:
return ContinuationOutcome.REFERENCE_COMPLETED
boundary = 0
for actual, reference in zip(region, expected, strict=False):
if actual != reference:
break
boundary += 1
shared = region[:boundary]
suffix = closure_state(shared, structure_format).closing_suffix
if suffix is not None and shared + suffix == region:
return ContinuationOutcome.REFERENCE_PREFIX_CLOSED_EARLY
return ContinuationOutcome.OTHER_CONTENT_CHANGE