| """The pure-Python ContextBench runner. |
| |
| The runner owns the turn protocol so an agent does not have to. It delivers one |
| operation per user turn, advances only on a standalone readiness marker, refuses an |
| early submit, enforces the budget wall on the agent's own reported context, |
| snapshots that context after every turn, and grades the run at the end. |
| |
| The invariant the runner exists to hold: an operation enters the agent's context as |
| a user message appended by the runner, before the agent can act on it. The agent |
| controls only *when* the next operation arrives, never its content or its route |
| into the context. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import json |
| from dataclasses import dataclass |
| from pathlib import Path |
| from typing import Any, Protocol, runtime_checkable |
|
|
| from . import stream as proto |
| from .graders import grade_run |
| from .stream import Op, render_op |
| from .tokens import count_tokens, record_snapshot |
|
|
| __all__ = [ |
| "ContextAgent", |
| "Instance", |
| "DEFAULT_SYSTEM_PROMPT", |
| "load_instance", |
| "run", |
| ] |
|
|
| DEFAULT_SYSTEM_PROMPT = ( |
| "You are a careful assistant working through a long stream of operations that " |
| "does not fit in your context window. Handle each operation as it arrives, keep " |
| "in your context exactly what later operations will need, and let go of the " |
| "rest.\n\n" + proto.MARKER_PARAGRAPH_REPLY |
| ) |
|
|
|
|
| @runtime_checkable |
| class ContextAgent(Protocol): |
| """What the runner needs from an agent. |
| |
| ``reset`` starts a fresh episode with the system prompt and the family |
| instruction. ``on_user_turn`` receives one user message -- an operation, or a |
| protocol message from the runner -- and returns the reply text. ``context`` |
| returns the agent's current message list, which the runner snapshots and |
| measures against the budget: an agent that hides its context from the runner |
| cannot be graded on the paper metric. |
| """ |
|
|
| def reset(self, system: str, instruction: str) -> None: ... |
|
|
| def on_user_turn(self, text: str) -> str: ... |
|
|
| def context(self) -> list[dict]: ... |
|
|
|
|
| @dataclass(frozen=True) |
| class Instance: |
| """One generated instance on disk.""" |
|
|
| path: Path |
| family: str |
| ops: list[Op] |
| gold: dict |
| meta: dict |
|
|
| @property |
| def n_ops(self) -> int: |
| return len(self.ops) |
|
|
|
|
| def load_instance(instance_dir: Path | str) -> Instance: |
| """Read ``chunks.jsonl``, ``gold.json`` and ``meta.json`` from a directory.""" |
| d = Path(instance_dir) |
| meta = json.loads((d / "meta.json").read_text(encoding="utf-8")) |
| gold = json.loads((d / "gold.json").read_text(encoding="utf-8")) |
| ops = proto.load_ops((d / "chunks.jsonl").read_text(encoding="utf-8").splitlines()) |
| family = meta.get("task_family") or (gold.get("meta") or {}).get("task_family") |
| if not family: |
| raise ValueError(f"{d}: meta.json has no task_family") |
| return Instance(path=d, family=family, ops=ops, gold=gold, meta=meta) |
|
|
|
|
| def instruction_for(instance: Instance, *, delivery: str = "reply") -> str: |
| """The instruction text for an instance's family.""" |
| import importlib |
|
|
| module = importlib.import_module( |
| f"contextbench.tasks.{instance.family}.generate" |
| ) |
| return module.instruction(instance.gold, delivery=delivery) |
|
|
|
|
| def run( |
| agent: ContextAgent, |
| instance_dir: Path | str, |
| *, |
| budget: int = 32768, |
| reserve: int = 2048, |
| out_dir: Path | str = "runs/latest", |
| max_turns: int | None = None, |
| system_prompt: str | None = None, |
| delivery: str = "reply", |
| overwrite: bool = False, |
| ) -> dict: |
| """Run one instance end to end and return the result dict. |
| |
| ``budget`` and ``reserve`` set the wall: a turn whose snapshot exceeds |
| ``budget - reserve`` tokens ends the run with ``terminated_by="budget_wall"``, |
| because a real serving stack would have refused the next request. ``max_turns`` |
| is a safety stop, not part of the task: leave it unset for a full horizon. |
| |
| Writes ``context_snapshots/turn-NNNN.json`` per turn, ``interactive_stream.json`` |
| and ``result.json`` into ``out_dir``, and returns the same result dict. |
| |
| ``out_dir`` must be empty or absent: the graders read every snapshot in it, so |
| files from an earlier run would be credited to this one. ``overwrite=True`` |
| deletes an existing ``out_dir`` first. |
| """ |
| instance = load_instance(instance_dir) |
| out = Path(out_dir) |
| if out.exists() and any(out.iterdir()): |
| if not overwrite: |
| raise FileExistsError( |
| f"{out} is not empty; the graders would read its old snapshots as part " |
| "of this run. Use a fresh directory or pass overwrite=True." |
| ) |
| import shutil |
|
|
| shutil.rmtree(out) |
| out.mkdir(parents=True, exist_ok=True) |
| usable = budget - reserve |
|
|
| instruction = instruction_for(instance, delivery=delivery) |
| agent.reset(system_prompt or DEFAULT_SYSTEM_PROMPT, instruction) |
|
|
| total_ops = instance.n_ops |
| delivered = 0 |
| step = 0 |
| terminated_by: str | None = None |
| peak_tokens = 0 |
|
|
| def _deliver_op(index: int) -> str: |
| return render_op(instance.ops[index], remaining=total_ops - (index + 1)) |
|
|
| if total_ops == 0: |
| terminated_by = "stream_exhausted" |
| pending: str | None = None |
| else: |
| pending = _deliver_op(0) |
| delivered = 1 |
|
|
| while pending is not None and terminated_by is None: |
| reply = agent.on_user_turn(pending) or "" |
| step += 1 |
|
|
| messages = list(agent.context() or []) |
| tokens, _ = count_tokens(messages) |
| peak_tokens = max(peak_tokens, tokens) |
| record_snapshot( |
| out, |
| step, |
| messages, |
| { |
| "n_ops_delivered": delivered, |
| "n_ops_total": total_ops, |
| "budget": budget, |
| "reserve": reserve, |
| }, |
| ) |
|
|
| if tokens > usable: |
| terminated_by = "budget_wall" |
| break |
|
|
| if proto.is_submit_line(reply) or proto.is_submit_command(reply): |
| if delivered < total_ops: |
| pending = proto.REFUSE_SUBMIT_TEXT |
| else: |
| terminated_by = "submit" |
| break |
| elif proto.is_ready_line(reply) or proto.is_ready_command(reply): |
| if delivered < total_ops: |
| pending = _deliver_op(delivered) |
| delivered += 1 |
| else: |
| terminated_by = "stream_exhausted" |
| break |
| elif proto.mentions_advance_marker(reply): |
| pending = proto.EXPLAIN_NON_STANDALONE_TEXT |
| else: |
| pending = proto.NO_MARKER_TEXT |
|
|
| if max_turns is not None and step >= max_turns: |
| terminated_by = "max_steps" |
| break |
|
|
| if terminated_by is None: |
| terminated_by = "stream_exhausted" |
|
|
| stream_record = { |
| "n_ops_delivered": delivered, |
| "n_ops_total": total_ops, |
| "terminated_by": terminated_by, |
| } |
| (out / "interactive_stream.json").write_text( |
| json.dumps(stream_record, indent=2) + "\n", encoding="utf-8" |
| ) |
|
|
| rewards = grade_run(out, instance.gold) |
| result: dict[str, Any] = { |
| "task_family": instance.family, |
| "instance_dir": str(instance.path), |
| "out_dir": str(out), |
| "budget": budget, |
| "reserve": reserve, |
| "n_turns": step, |
| "peak_tokens": peak_tokens, |
| "reward": rewards.get("reward", 0.0), |
| "rewards": rewards, |
| **stream_record, |
| } |
| (out / "result.json").write_text( |
| json.dumps(result, indent=2, default=str) + "\n", encoding="utf-8" |
| ) |
| return result |
|
|
