| from __future__ import annotations |
|
|
| import itertools |
| import random |
| from dataclasses import dataclass |
| from typing import Any |
|
|
| from .models import BenchCase |
| from .tokenizer import TokenizerProtocol |
| from .util import sha256_json |
|
|
|
|
| SYSTEM_PROMPT = ( |
| "You are running a deterministic long-context evaluation. Read the complete " |
| "context, ignore stale or decoy records, and return only the requested bare JSON." |
| ) |
|
|
|
|
| @dataclass(frozen=True) |
| class ContextSpec: |
| suite_id: str |
| matrix: str |
| family: str |
| target_tokens: int |
| position: float |
| seed: int |
| query_placement: str = "after" |
|
|
| @property |
| def case_id(self) -> str: |
| position = f"p{round(self.position * 100):02d}" |
| return ( |
| f"{self.matrix}__{self.family}__t{self.target_tokens}__{position}" |
| f"__s{self.seed}__q{self.query_placement}" |
| ) |
|
|
|
|
| def expand_context_config(config: dict[str, Any]) -> list[ContextSpec]: |
| suite_id = str(config["suite_id"]) |
| context_window = int(config.get("context_window") or 0) |
| reserved_output = int(config.get("reserved_output_tokens") or 0) |
| maximum_prompt = context_window - reserved_output if context_window and reserved_output else None |
| specs: list[ContextSpec] = [] |
| for matrix in config["matrices"]: |
| values = itertools.product( |
| matrix["families"], |
| matrix["lengths"], |
| matrix["positions"], |
| matrix["seeds"], |
| matrix.get("query_placements", ["after"]), |
| ) |
| for family, length, position, seed, placement in values: |
| if not 0 < float(position) < 1: |
| raise ValueError(f"Position must be between zero and one: {position}") |
| if placement not in {"before", "after"}: |
| raise ValueError(f"Unsupported query placement: {placement}") |
| if maximum_prompt is not None and int(length) > maximum_prompt: |
| raise ValueError( |
| f"Prompt length {length} exceeds context-minus-output budget {maximum_prompt}" |
| ) |
| specs.append( |
| ContextSpec( |
| suite_id=suite_id, |
| matrix=str(matrix["name"]), |
| family=str(family), |
| target_tokens=int(length), |
| position=float(position), |
| seed=int(seed), |
| query_placement=str(placement), |
| ) |
| ) |
| identifiers = [item.case_id for item in specs] |
| if len(identifiers) != len(set(identifiers)): |
| raise ValueError("Context configuration produces duplicate case identifiers") |
| return specs |
|
|
|
|
| def _secret(seed: int, label: str) -> str: |
| rng = random.Random(f"{seed}:{label}") |
| left = ["amber", "cedar", "indigo", "marble", "opal", "quartz", "saffron"] |
| right = ["falcon", "harbor", "lighthouse", "otter", "raven", "willow"] |
| return f"{rng.choice(left)}-{rng.randrange(100000, 999999)}-{rng.choice(right)}" |
|
|
|
|
| def _task_payload(spec: ContextSpec) -> tuple[list[tuple[float, str, str]], str, dict[str, Any]]: |
| target = _secret(spec.seed, spec.family) |
| decoy_a = _secret(spec.seed + 101, "decoy-a") |
| decoy_b = _secret(spec.seed + 202, "decoy-b") |
| marker = f"<<SX_PRIMARY_{spec.seed}_{spec.family.upper()}>>" |
| common: dict[str, Any] = {"record": target} |
| insertions: list[tuple[float, str, str]] = [ |
| (0.08, "decoy-a", f"STALE RECORD record={decoy_a} status=revoked revision=2"), |
| (0.92, "decoy-b", f"DECOY RECORD record={decoy_b} status=simulation revision=99"), |
| ] |
|
|
| if spec.family == "single_key": |
| primary = f"{marker} CANONICAL RECORD record={target} status=active" |
| query = "Return the active canonical record." |
| elif spec.family == "binding": |
| key = f"device-{(spec.seed % 83) + 10}" |
| primary = ( |
| f"{marker} AUTHORITATIVE BINDING device={key} record={target} " |
| "status=active; similar device identifiers are unrelated." |
| ) |
| common["device"] = key |
| query = f"Return the active record bound specifically to device {key}." |
| elif spec.family == "latest_record": |
| primary = f"{marker} CHANGELOG record={target} revision=12 state=current" |
| insertions.extend( |
| [ |
| (0.19, "older", f"CHANGELOG record={decoy_a} revision=10 state=superseded"), |
| (0.77, "newer-decoy", f"CHANGELOG record={decoy_b} revision=13 state=test-only"), |
| ] |
| ) |
| common["revision"] = 12 |
| query = "Return the highest production revision marked current, excluding test-only entries." |
| elif spec.family == "multi_hop": |
| relay = f"relay-{(spec.seed % 71) + 20}" |
| zone = ["north", "south", "east", "west"][spec.seed % 4] |
| primary = f"{marker} ROUTE MAP record={target} uses_relay={relay}" |
| insertions.append( |
| (1.0 - spec.position, "hop-two", f"RELAY DIRECTORY relay={relay} final_zone={zone}"), |
| ) |
| common.update({"relay": relay, "zone": zone}) |
| query = "Follow the route map through the relay directory and return record, relay, and final zone." |
| elif spec.family == "semantic": |
| callsign = f"unit-{(spec.seed % 89) + 10}" |
| primary = ( |
| f"{marker} The only solar-powered courier approved for silent night delivery " |
| f"has registry value {target} and operational callsign {callsign}." |
| ) |
| common["callsign"] = callsign |
| query = ( |
| "Identify the registry value and callsign of the emission-free messenger " |
| "authorized to work after dark." |
| ) |
| elif spec.family == "state_tracking": |
| counter = 10 + spec.seed % 7 |
| add_a = 3 + spec.seed % 5 |
| subtract = 1 + spec.seed % 3 |
| final = counter + add_a - subtract |
| primary = f"{marker} STATE stream={target} value={counter} sequence=1" |
| insertions.extend( |
| [ |
| (min(0.95, spec.position + 0.18), "update-a", f"UPDATE stream={target} add={add_a} sequence=2"), |
| (min(0.98, spec.position + 0.34), "update-b", f"UPDATE stream={target} subtract={subtract} sequence=3"), |
| ] |
| ) |
| common["final_value"] = final |
| query = "Apply the ordered updates and return the stream record and final value." |
| else: |
| raise ValueError(f"Unknown context family: {spec.family}") |
|
|
| primary_end_marker = f"<<SX_PRIMARY_END_{spec.seed}_{spec.family.upper()}>>" |
| insertions.append((spec.position, "primary", primary + " " + primary_end_marker)) |
| return sorted(insertions, key=lambda item: (item[0], item[1])), query, common |
|
|
|
|
| def _filler_pool(tokenizer: TokenizerProtocol, seed: int) -> list[int]: |
| rng = random.Random(seed) |
| services = ["atlas", "beacon", "cinder", "delta", "ember", "fjord", "garnet", "helios"] |
| states = ["nominal", "queued", "retrying", "stable", "verified", "warming"] |
| regions = ["north-ridge", "west-field", "central-bay", "east-grove"] |
| lines = [] |
| for index in range(5000): |
| service = rng.choice(services) |
| state = rng.choice(states) |
| region = rng.choice(regions) |
| trace = f"{rng.getrandbits(48):012x}" |
| lines.append( |
| f"event {index:05d}: service={service} region={region} state={state} " |
| f"latency_ms={rng.randrange(3, 997)} trace={trace}; routine telemetry only." |
| ) |
| token_ids = tokenizer.encode("\n" + "\n".join(lines) + "\n") |
| if len(token_ids) < 1000: |
| raise ValueError("Tokenizer produced an unexpectedly small filler pool") |
| return token_ids |
|
|
|
|
| def _take(pool: list[int], count: int, offset: int) -> list[int]: |
| if count <= 0: |
| return [] |
| start = offset % len(pool) |
| rotated = pool[start:] + pool[:start] |
| repeats, remainder = divmod(count, len(rotated)) |
| return rotated * repeats + rotated[:remainder] |
|
|
|
|
| def _allocate_filler(total: int, insertion_positions: list[float]) -> list[int]: |
| gaps = [] |
| previous = 0.0 |
| for position in insertion_positions: |
| gaps.append(max(0.0, position - previous)) |
| previous = position |
| gaps.append(max(0.0, 1.0 - previous)) |
| raw = [total * gap for gap in gaps] |
| values = [int(value) for value in raw] |
| for index in sorted(range(len(raw)), key=lambda item: raw[item] - values[item], reverse=True): |
| if sum(values) >= total: |
| break |
| values[index] += 1 |
| return values |
|
|
|
|
| def build_context_case(spec: ContextSpec, tokenizer: TokenizerProtocol) -> BenchCase: |
| insertions, query, expected = _task_payload(spec) |
| start_sentinel = f"SX_START_{spec.seed}_{spec.family}" |
| end_sentinel = f"SX_END_{spec.seed}_{spec.family}" |
| expected = {"start_sentinel": start_sentinel, **expected, "end_sentinel": end_sentinel} |
| keys = ", ".join(expected) |
| query_text = f"{query} Return exactly one JSON object with keys: {keys}." |
| prefix_query = query_text + "\n\n" if spec.query_placement == "before" else "" |
| suffix_query = "\n\n" + query_text if spec.query_placement == "after" else "" |
|
|
| fixed_user = ( |
| prefix_query |
| + f"BEGIN CONTEXT\nSTART SENTINEL: {start_sentinel}\n" |
| + "\n".join(text for _, _, text in insertions) |
| + f"\nEND SENTINEL: {end_sentinel}\nEND CONTEXT" |
| + suffix_query |
| ) |
| fixed_messages = [ |
| {"role": "system", "content": SYSTEM_PROMPT}, |
| {"role": "user", "content": fixed_user}, |
| ] |
| fixed_tokens = len(tokenizer.encode(tokenizer.render_chat(fixed_messages))) |
| available = spec.target_tokens - fixed_tokens |
| if available < 512: |
| raise ValueError( |
| f"Target {spec.target_tokens} is too small for {spec.family}; only {available} filler tokens remain" |
| ) |
|
|
| pool = _filler_pool(tokenizer, spec.seed) |
| allocations = _allocate_filler(available, [item[0] for item in insertions]) |
| segments = [_take(pool, size, spec.seed * 97 + index * 7919) for index, size in enumerate(allocations)] |
| primary_index = next(index for index, item in enumerate(insertions) if item[1] == "primary") |
| primary_marker = insertions[primary_index][2].split(" ", 1)[0] |
| primary_end_marker = f"<<SX_PRIMARY_END_{spec.seed}_{spec.family.upper()}>>" |
|
|
| def make_messages() -> list[dict[str, Any]]: |
| context_parts = [f"START SENTINEL: {start_sentinel}\n"] |
| for index, (_, _, insertion) in enumerate(insertions): |
| context_parts.append(tokenizer.decode(segments[index])) |
| context_parts.append("\n" + insertion + "\n") |
| context_parts.append(tokenizer.decode(segments[-1])) |
| context_parts.append(f"\nEND SENTINEL: {end_sentinel}") |
| user = prefix_query + "BEGIN CONTEXT\n" + "".join(context_parts) + "\nEND CONTEXT" + suffix_query |
| return [ |
| {"role": "system", "content": SYSTEM_PROMPT}, |
| {"role": "user", "content": user}, |
| ] |
|
|
| diagnostics: list[tuple[int, int, int]] = [] |
| for iteration in range(24): |
| messages = make_messages() |
| rendered = tokenizer.render_chat(messages) |
| actual_total = len(tokenizer.encode(rendered)) |
| total_delta = spec.target_tokens - actual_total |
| primary_start = tokenizer.token_offset(rendered, primary_marker) |
| primary_end = tokenizer.token_offset(rendered, primary_end_marker) |
| actual_offset = round((primary_start + primary_end) / 2) |
| context_start = tokenizer.token_offset(rendered, "START SENTINEL:") |
| context_end = tokenizer.token_offset(rendered, "END SENTINEL:") |
| diagnostics.append((actual_total, actual_offset, total_delta)) |
| if total_delta: |
| if total_delta > 0: |
| segments[-1].extend(_take(pool, total_delta, spec.seed + iteration * 3571)) |
| else: |
| remaining = -total_delta |
| for segment in reversed(segments): |
| removed = min(remaining, len(segment)) |
| if removed: |
| del segment[-removed:] |
| remaining -= removed |
| if remaining == 0: |
| break |
| if remaining: |
| raise ValueError("Unable to trim context to requested token count") |
| continue |
|
|
| desired_offset = context_start + round((context_end - context_start) * spec.position) |
| position_delta = desired_offset - actual_offset |
| tolerance = max(4, round(spec.target_tokens * 0.0025)) |
| if abs(position_delta) <= tolerance: |
| break |
| before = segments[primary_index] |
| after = segments[primary_index + 1] |
| if position_delta > 0: |
| movement = min(position_delta, len(after)) |
| before.extend(_take(pool, movement, spec.seed + iteration * 1237)) |
| del after[:movement] |
| else: |
| movement = min(-position_delta, len(before)) |
| del before[-movement:] |
| after[:0] = _take(pool, movement, spec.seed + iteration * 1237) |
| else: |
| raise RuntimeError( |
| f"Exact context construction did not converge for {spec.case_id}; " |
| f"last iterations={diagnostics[-6:]}" |
| ) |
|
|
| messages = make_messages() |
| rendered = tokenizer.render_chat(messages) |
| actual_total = len(tokenizer.encode(rendered)) |
| primary_start = tokenizer.token_offset(rendered, primary_marker) |
| primary_end = tokenizer.token_offset(rendered, primary_end_marker) |
| actual_offset = round((primary_start + primary_end) / 2) |
| context_start = tokenizer.token_offset(rendered, "START SENTINEL:") |
| context_end = tokenizer.token_offset(rendered, "END SENTINEL:") |
| if actual_total != spec.target_tokens: |
| raise AssertionError(f"Requested {spec.target_tokens} rendered tokens, produced {actual_total}") |
| actual_position = (actual_offset - context_start) / (context_end - context_start) |
| metadata = { |
| "matrix": spec.matrix, |
| "family": spec.family, |
| "seed": spec.seed, |
| "target_prompt_tokens": spec.target_tokens, |
| "actual_rendered_tokens": actual_total, |
| "requested_position": spec.position, |
| "actual_primary_token_offset": actual_offset, |
| "actual_primary_start_token_offset": primary_start, |
| "actual_primary_end_token_offset": primary_end, |
| "actual_primary_position": actual_position, |
| "context_start_token_offset": context_start, |
| "context_end_token_offset": context_end, |
| "query_placement": spec.query_placement, |
| "tokenizer_fingerprint": tokenizer.fingerprint, |
| "prompt_hash": sha256_json(messages), |
| "truncation_sentinels": [start_sentinel, end_sentinel], |
| } |
| return BenchCase( |
| case_id=spec.case_id, |
| suite_id=spec.suite_id, |
| lane="long-context", |
| messages=messages, |
| scorer="strict_json_exact", |
| expected=expected, |
| max_output_tokens=2048, |
| metadata=metadata, |
| ) |
|
|
