# Copyright The Marin Authors # SPDX-License-Identifier: Apache-2.0 """Inspect JSON prefixes without treating unfinished generation as invalid JSON.""" import json import re from dataclasses import dataclass from enum import StrEnum from types import MappingProxyType class PrefixStatus(StrEnum): COMPLETE = "complete" EXTENDABLE = "extendable" INVALID = "invalid" @dataclass(frozen=True) class ClosureState: """Prefix validity and the first outer completion boundary, when one exists. Offsets count Python characters. A completed region followed by extra content remains INVALID but retains its exclusive completion offset. A nonempty completion guard is the separator needed to keep an EOF-valid completion valid when generation continues, such as a fence's newline. """ status: PrefixStatus open_structures: tuple[str, ...] closing_suffix: str | None error_offset: int | None = None reason: str | None = None completion_offset: int | None = None completion_guard: str = "" class _PrefixEnd(Exception): def __init__(self, suffix: str | None): self.suffix = suffix class _InvalidPrefix(Exception): def __init__(self, offset: int, reason: str): self.offset = offset self.reason = reason _NUMBER = re.compile(r"-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?") _NUMBER_PREFIX = re.compile(r"-?(?:(?:0|[1-9][0-9]*)(?:\.[0-9]*)?|(?:0|[1-9][0-9]*)(?:\.[0-9]+)?[eE][+-]?[0-9]*)?") _WHITESPACE = " \t\r\n" _HEX = frozenset("0123456789abcdefABCDEF") _CLOSE = MappingProxyType({"{": "}", "[": "]", '"': '"'}) _FENCE_INDENT = r" {0,3}" class _JsonPrefix: def __init__(self, text: str): self.text = text self.position = 0 self.open: list[str] = [] def skip_space(self): while self.position < len(self.text) and self.text[self.position] in _WHITESPACE: self.position += 1 def suffix(self) -> str: return "".join(_CLOSE[value] for value in reversed(self.open)) def fail(self, reason: str): raise _InvalidPrefix(self.position, reason) def value(self): self.skip_space() if self.position == len(self.text): raise _PrefixEnd(None) char = self.text[self.position] if char == '"': self.string(key=False) elif char == "{": self.object() elif char == "[": self.array() elif char in "tfn": literal = {"t": "true", "f": "false", "n": "null"}[char] for expected in literal: if self.position == len(self.text): raise _PrefixEnd(None) if self.text[self.position] != expected: self.fail("Invalid JSON literal") self.position += 1 elif char in "-0123456789": self.number() else: self.fail("Expected a JSON value") def number(self): start = self.position while self.position < len(self.text): char = self.text[self.position] if char in _WHITESPACE + ",]}": break candidate = self.text[start : self.position + 1] if not _NUMBER_PREFIX.fullmatch(candidate): self.fail("Invalid JSON number") self.position += 1 number = self.text[start : self.position] if _NUMBER.fullmatch(number): return if self.position == len(self.text): raise _PrefixEnd(None) self.fail("Unfinished JSON number") def string(self, *, key: bool) -> str: start = self.position self.position += 1 self.open.append('"') while self.position < len(self.text): char = self.text[self.position] if char == '"': self.position += 1 self.open.pop() return json.loads(self.text[start : self.position]) if ord(char) < 32: self.fail("Unescaped control character in JSON string") self.position += 1 if char != "\\": continue if self.position == len(self.text): raise _PrefixEnd(None) escape = self.text[self.position] if escape not in '"\\/bfnrtu': self.fail("Invalid JSON escape") self.position += 1 if escape == "u": for _ in range(4): if self.position == len(self.text): raise _PrefixEnd(None) if self.text[self.position] not in _HEX: self.fail("Invalid JSON unicode escape") self.position += 1 raise _PrefixEnd(None if key else self.suffix()) def object(self): self.open.append("{") self.position += 1 self.skip_space() if self.position == len(self.text): raise _PrefixEnd(self.suffix()) if self.text[self.position] == "}": self.position += 1 self.open.pop() return keys = set() while True: if self.position == len(self.text): raise _PrefixEnd(None) if self.text[self.position] != '"': self.fail("Expected an object key") key = self.string(key=True) if key in keys: self.position -= 1 self.fail("Duplicate JSON key") keys.add(key) self.skip_space() if self.position == len(self.text): raise _PrefixEnd(None) if self.text[self.position] != ":": self.fail("Expected colon after object key") self.position += 1 self.value() if self.separator("}"): return def array(self): self.open.append("[") self.position += 1 self.skip_space() if self.position == len(self.text): raise _PrefixEnd(self.suffix()) if self.text[self.position] == "]": self.position += 1 self.open.pop() return while True: self.value() if self.separator("]"): return def separator(self, closer: str) -> bool: """Consume a separator; return True for a closer and False for a comma.""" self.skip_space() if self.position == len(self.text): raise _PrefixEnd(self.suffix()) char = self.text[self.position] if char == closer: self.position += 1 self.open.pop() return True if char != ",": self.fail("Expected comma or matching closer") self.position += 1 self.skip_space() return False def json_closure_state(prefix: str) -> ClosureState: """Classify a JSON prefix and provide a syntax-only closing suffix if possible. An extendable prefix is not a generation failure until the completion boundary. A suffix never fills a key, value, literal, number, or escape. Closing a string or empty container may still truncate intended content: callers must separately verify the semantic boundary before using a suffix as supervision. Duplicate object keys are rejected. Offsets index decoded Python characters, not model tokens or UTF-8 bytes. """ parser = _JsonPrefix(prefix) try: parser.value() completed_at = parser.position parser.skip_space() if parser.position != len(prefix): return ClosureState( PrefixStatus.INVALID, (), None, parser.position, "Content after the complete JSON value", completed_at, ) except _PrefixEnd as error: return ClosureState(PrefixStatus.EXTENDABLE, tuple(parser.open), error.suffix) except _InvalidPrefix as error: return ClosureState(PrefixStatus.INVALID, tuple(parser.open), None, error.offset, error.reason) return ClosureState(PrefixStatus.COMPLETE, (), "", completion_offset=completed_at) def delimited_json_closure_state(prefix: str, *, opener: str, closer: str) -> ClosureState: """Inspect one explicitly delimited JSON region, including its opening marker. Markers inside JSON strings are literal content. The JSON payload has no schema checks here. Trailing non-whitespace content after the close marker is outside this single-region contract and is rejected. """ if not opener or not closer or opener == closer: raise ValueError("Require distinct nonempty JSON delimiters") if opener.startswith(prefix) and prefix != opener: return ClosureState(PrefixStatus.EXTENDABLE, (), None) if not prefix.startswith(opener): return ClosureState(PrefixStatus.INVALID, (), None, 0, "Expected opening marker") parser = _JsonPrefix(prefix[len(opener) :]) try: parser.value() parser.skip_space() except _PrefixEnd as error: suffix = None if error.suffix is None else error.suffix + closer return ClosureState(PrefixStatus.EXTENDABLE, (opener, *parser.open), suffix) except _InvalidPrefix as error: return ClosureState(PrefixStatus.INVALID, (opener, *parser.open), None, len(opener) + error.offset, error.reason) offset = len(opener) + parser.position remainder = prefix[offset:] if closer.startswith(remainder) and remainder != closer: return ClosureState(PrefixStatus.EXTENDABLE, (opener,), closer[len(remainder) :]) if remainder.startswith(closer): tail = remainder[len(closer) :] completed_at = offset + len(closer) if not tail.strip(_WHITESPACE): return ClosureState(PrefixStatus.COMPLETE, (), "", completion_offset=completed_at) offset += len(closer) + len(tail) - len(tail.lstrip(_WHITESPACE)) return ClosureState(PrefixStatus.INVALID, (), None, offset, "Content after closing marker", completed_at) matching = 0 while matching < min(len(remainder), len(closer)) and remainder[matching] == closer[matching]: matching += 1 return ClosureState(PrefixStatus.INVALID, (opener,), None, offset + matching, "Expected closing marker") def paired_marker_closure_state(prefix: str, *, opener: str, closer: str) -> ClosureState: """Inspect one non-nesting marker pair around opaque content. Use only where these exact markers are structural, such as model reasoning special tokens. This is not a parser for prose quoting the marker spelling. Content completion requires separate evidence before suffix supervision. """ if not opener or not closer or opener == closer: raise ValueError("Require distinct nonempty markers") if opener.startswith(prefix) and prefix != opener: return ClosureState(PrefixStatus.EXTENDABLE, (), None) if not prefix.startswith(opener): return ClosureState(PrefixStatus.INVALID, (), None, 0, "Expected opening marker") body = prefix[len(opener) :] close_at = body.find(closer) repeat_at = body.find(opener) if repeat_at >= 0 and (close_at < 0 or repeat_at < close_at): return ClosureState( PrefixStatus.INVALID, (opener,), None, len(opener) + repeat_at + len(opener) - 1, "Repeated opening marker" ) if close_at >= 0: tail = body[close_at + len(closer) :] completed_at = len(opener) + close_at + len(closer) if tail.strip(_WHITESPACE): offset = len(opener) + close_at + len(closer) + len(tail) - len(tail.lstrip(_WHITESPACE)) return ClosureState(PrefixStatus.INVALID, (), None, offset, "Content after closing marker", completed_at) return ClosureState(PrefixStatus.COMPLETE, (), "", completion_offset=completed_at) for length in range(min(len(body), len(closer) - 1), 0, -1): if body.endswith(closer[:length]): return ClosureState(PrefixStatus.EXTENDABLE, (opener,), closer[length:]) return ClosureState(PrefixStatus.EXTENDABLE, (opener,), closer) def required_code_fence_state(prefix: str) -> ClosureState: """Inspect a single Markdown code block whose task explicitly requires closure. Support backtick and tilde fences, at most three opening/closing indent spaces, and closing runs at least as long as the opener. Body punctuation is opaque. Ordinary Markdown permits an unclosed fence at EOF; this stricter contract must therefore be declared in the task, not inferred globally. """ lines = prefix.split("\n") opening = re.fullmatch(_FENCE_INDENT + r"(`{3,}|~{3,})([^\n]*)", lines[0]) if opening is None: if re.fullmatch(_FENCE_INDENT + r"(?:`{0,2}|~{0,2})", prefix): return ClosureState(PrefixStatus.EXTENDABLE, (), None) return ClosureState(PrefixStatus.INVALID, (), None, 0, "Expected code fence") fence, info = opening.groups() if fence[0] == "`" and "`" in info: return ClosureState(PrefixStatus.INVALID, (), None, lines[0].find("`", opening.end(1)), "Backtick in fence info") closer_pattern = re.compile(_FENCE_INDENT + re.escape(fence[0]) + "{" + str(len(fence)) + r",}[ \t]*") offset = len(lines[0]) + 1 for index, line in enumerate(lines[1:], 1): if closer_pattern.fullmatch(line): tail = "\n".join(lines[index + 1 :]) completed_at = offset + len(line) if tail.strip(_WHITESPACE): return ClosureState( PrefixStatus.INVALID, (), None, offset + len(line) + 1, "Content after code fence", completed_at ) return ClosureState( PrefixStatus.COMPLETE, (), "", completion_offset=completed_at, completion_guard="\n" if index == len(lines) - 1 else "", ) offset += len(line) + 1 last = lines[-1] if len(lines) > 1 and re.fullmatch(_FENCE_INDENT + re.escape(fence[0]) + "{0," + str(len(fence) - 1) + "}", last): suffix = fence[len(last.lstrip(" ")) :] else: suffix = "\n" + fence return ClosureState(PrefixStatus.EXTENDABLE, (fence,), suffix)