Download tests/offline_check.py from ZJUSCL/TwinLab-Bench: direct link, hf CLI and curl.
- Browser
- Download file 55.5 kB
-
https://huggingface.co/datasets/ZJUSCL/TwinLab-Bench/resolve/main/tests/offline_check.py
- Command line
-
hf download hf://datasets/ZJUSCL/TwinLab-Bench/tests/offline_check.py
-
curl -L -o offline_check.py https://huggingface.co/datasets/ZJUSCL/TwinLab-Bench/resolve/main/tests/offline_check.py
55.5 kB
| """Offline test of every case (no model calls): case loading, actor brief, report tool, environment schema and | |
| system prompt, and the Lab's accounting and checkpoint rules against a scripted fake environment. | |
| Run it after any change to twinlab/ or to a case. | |
| python tests/offline_check.py # all cases | |
| python tests/offline_check.py cases/0*/case.yaml -v # some cases, printing the brief and the lab responses | |
| """ | |
| import json | |
| import re | |
| import subprocess | |
| import sys | |
| import tempfile | |
| import traceback | |
| from pathlib import Path | |
| ROOT = Path(__file__).resolve().parents[1] | |
| sys.path.insert(0, str(ROOT)) # run from a checkout without installing | |
| from twinlab.case import Case, case_name # noqa: E402 | |
| from twinlab.env_agent import EnvAgent, response_schema # noqa: E402 | |
| from twinlab.lab import Lab # noqa: E402 | |
| from twinlab.prompts import MESSAGES # noqa: E402 | |
| class FakeEnv: | |
| """Returns scripted environment answers in order and writes a Claude Code-shaped session transcript (the Lab | |
| bills from the CHARGE lines in it). A script entry is an answer, or (answer, [(command, output), ...]).""" | |
| def __init__(self, ws, script): | |
| self.ws, self.script = ws, list(script) | |
| self.path = ws.parent / "fake_env_transcript.jsonl" | |
| self.path.write_text("") | |
| self.n_tools = 0 | |
| self.guard_log = ws.parent / "env_guard.jsonl" # twinlab/calc_guard.py log; unguarded unless a test sets it | |
| self.extra_env = {} | |
| def transcript(self): | |
| return self.path | |
| def write_turn(self, ledger, shell, notes): | |
| # harness notes travel in the same user message as the request header (twinlab.env_agent.EnvAgent.step) | |
| note_txt = "".join(f"\n- {n}" for n in notes) | |
| lines = [{"message": {"role": "user", "content": f"## Actor request #{ledger['n_requests'] + 1}\nreq" | |
| + (f"\n## Harness notes since your last turn{note_txt}\n" | |
| if notes else "")}}] | |
| for cmd, out in shell: | |
| self.n_tools += 1 | |
| tid = f"t{self.n_tools}" | |
| lines.append({"message": {"role": "assistant", "content": [ | |
| {"type": "tool_use", "id": tid, "name": "Bash", "input": {"command": cmd}}]}}) | |
| lines.append({"message": {"role": "user", "content": [ | |
| {"type": "tool_result", "tool_use_id": tid, "content": out}]}}) | |
| with self.path.open("a") as f: | |
| f.write("".join(json.dumps(x) + "\n" for x in lines)) | |
| def step(self, request, params, ledger, notes, noise): | |
| self.notes_seen = list(notes) | |
| entry = self.script.pop(0) | |
| ans, shell = entry if isinstance(entry, tuple) else (entry, []) | |
| self.write_turn(ledger, shell, notes) | |
| return ans | |
| def state(self): | |
| return {} | |
| def restore(self, st): | |
| pass | |
| def resolve_image(self, rel): | |
| raise AssertionError("no images in the fake environment") | |
| def answer(**kw) -> dict: | |
| base = {"verdict": "performed", "action_types": [], "consumed": [], "stopped_at_checkpoint": "", | |
| "deferred_steps": [], "observation": "obs", "not_performed_items": [], "parameter_resolution": [], | |
| "images": [], "grounding": "g"} | |
| base.update(kw) | |
| return base | |
| # Traces that tell the actor the record was edited or assembled (realism pilot 2026-10-23, user: blinding must not | |
| # show; synthetic content must look real without contradicting facts). Matched case-insensitively in the brief and | |
| # every text file of the rendered actor workspace. | |
| AUTHORING_TRACES = re.compile("|".join([ | |
| r"\[(link )?removed\]", r"\[figure omitted\]", r"\[redacted\]", r"\bredacted\b", | |
| r"replaced (by|with) (roles?|codes?|placeholders?)", r"\b(are|is|were|was) not named\b", | |
| r"\banonymi[sz]ed\b", r"\bde-?identified\b", r"\bpseudonymi[sz]ed\b", r"see the task brief", | |
| ]), re.IGNORECASE) | |
| def check_actor_view_traces(case: Case, brief: str): | |
| with tempfile.TemporaryDirectory() as td: | |
| ws = Path(td) / "ws" | |
| case.write_actor_workspace(ws) | |
| texts = [("BRIEF", brief)] + [(str(f.relative_to(ws)), f.read_text(encoding="utf-8")) | |
| for f in sorted(ws.rglob("*")) if f.is_file() and case.is_text_file(f)] | |
| hits = [f"{name}:{i}: {m.group(0)!r}" for name, t in texts for i, line in enumerate(t.split("\n"), 1) | |
| for m in AUTHORING_TRACES.finditer(line)] | |
| assert not hits, f"authoring traces in the actor view: {hits[:8]}" | |
| named = [name for name, t in texts if case_name(case.id) in t] # the guard would withhold these files' content | |
| assert not named, f"the case name {case_name(case.id)!r} is in the actor view: {named[:8]}" | |
| def check(case_path: Path, verbose: bool): | |
| case = Case(case_path, "case") | |
| brief = case.actor_prompt() | |
| check_actor_view_traces(case, brief) | |
| sch = response_schema(list(case.actions), list(case.consumables), [c["id"] for c in case.checkpoints["list"]]) | |
| ev = case.env_view_yaml() | |
| for s in case.d["harness"]["env_hidden_sections"]: | |
| assert f"\n{s}:" not in ev, f"hidden section {s} in the environment view" | |
| with tempfile.TemporaryDirectory() as td: # builds the env workspace and system prompt, no model call | |
| EnvAgent(case, Path(td), "no-model", resume=False) | |
| a0 = list(case.actions)[0] | |
| item = next(iter(case.consumables), None) | |
| cps = [c["id"] for c in case.checkpoints["list"]] | |
| script = [answer(action_types=[a0], consumed=[{"item": item, "n": 1}] if item else [])] | |
| if case.checkpoints["enforce"]: | |
| script.append(answer(action_types=[a0], stopped_at_checkpoint=cps[0], deferred_steps=["step B", "step C"])) | |
| with tempfile.TemporaryDirectory() as td: | |
| td = Path(td) | |
| ws = td / "env_ws" | |
| ws.mkdir() | |
| (ws / "session_record.md").write_text("") | |
| lab = Lab(case, FakeEnv(ws, script), td, seed=0) | |
| texts = [lab.call("lab", {"request": f"req {i}"})["content"][0]["text"] for i in range(len(script))] | |
| assert lab.cost_used == sum(case.actions[a0]["cost"] for _ in script), lab.cost_used | |
| if item: | |
| assert lab.materials_left()[item] == case.consumables[item] - case.initial_consumed[item] - 1 | |
| if not case.checkpoints["enforce"]: # a checkpoint stop must be rejected when checkpoints are off | |
| lab.env.script = [answer(action_types=[a0], stopped_at_checkpoint="x", deferred_steps=["y"])] | |
| try: | |
| lab.call("lab", {"request": "bad"}) | |
| raise SystemExit("expected an assertion for a checkpoint stop with checkpoints disabled") | |
| except AssertionError: | |
| pass | |
| # a whole-request refusal shows its per-item reasons, as partial execution does (2026-10-29) | |
| lab.env.script = [answer(verdict="not_simulatable", observation="", not_performed_items=["item X: reason R"])] | |
| t = lab.call("lab", {"request": "refused"})["content"][0]["text"] | |
| assert "\n- item X: reason R" in t, t | |
| # ... and the observation text, where the env often puts the decline reasons (062-02, 069-02; 2026-10-29) | |
| lab.env.script = [answer(verdict="not_simulatable", observation="REFUSED item Y: reason S", | |
| not_performed_items=["item Y"])] | |
| t = lab.call("lab", {"request": "refused with reasons in observation"})["content"][0]["text"] | |
| assert "REFUSED item Y: reason S" in t and "\n- item Y" in t, t | |
| lab.env.script = [answer(verdict="not_simulatable", observation="UNAVAILABLE: reason U")] | |
| t = lab.call("lab", {"request": "refused, no items"})["content"][0]["text"] | |
| assert "UNAVAILABLE: reason U" in t and MESSAGES["not_simulatable"] in t, t | |
| r = lab.call("submit_final_report", {k: "x" for k in case.final_report["required"]}) | |
| assert not r["isError"], r | |
| if verbose: | |
| print(f"----- {case.id}: actor brief -----\n{brief}") | |
| print("report tool", json.dumps(case.report_tool_schema())[:300]) | |
| print("env schema keys", list(sch["properties"])) | |
| for i, t in enumerate(texts): | |
| print(f"----- lab response {i} -----\n{t}") | |
| (ROOT / "tmp").mkdir(exist_ok=True) # check_calc_guard needs a temporary directory outside /tmp | |
| ROLLBACK_CASE = ROOT / "cases/044-seahorse-patient-ocr-01/case.yaml" # any case with a calculator works | |
| class CalcEnv(FakeEnv): | |
| """Writes calc_state like a calculator command (vials used so far), then answers or fails a check.""" | |
| def step(self, request, params, ledger, notes, noise): | |
| used, ok = self.script.pop(0) | |
| self.write_turn(ledger, [], notes) | |
| (self.ws / "calc_state").mkdir(exist_ok=True) | |
| (self.ws / "calc_state" / "lab.json").write_text(json.dumps({"used": used})) | |
| assert ok, "scripted environment failure after the calculator ran" | |
| return answer(action_types=["inspect"]) | |
| def check_resume_rollback(): | |
| """Resume after a request that failed mid-way: calc_state must return to its state before that request, and a | |
| resume after a committed request must leave it alone (twinlab.lab snapshot/rollback, 2026-10-19).""" | |
| case = Case(ROLLBACK_CASE, "case") | |
| used = lambda ws: json.loads((ws / "calc_state" / "lab.json").read_text())["used"] # noqa: E731 | |
| with tempfile.TemporaryDirectory() as td: | |
| td = Path(td) | |
| ws = td / "env_ws" | |
| ws.mkdir() | |
| (ws / "session_record.md").write_text("") | |
| env = CalcEnv(ws, [(1, True), (16, False)]) | |
| lab = Lab(case, env, td, seed=0) | |
| lab.call("lab", {"request": "req 1"}) | |
| assert used(ws) == 1 | |
| try: # as mcp_server does on an exception inside the Lab | |
| lab.call("lab", {"request": "req 2"}) | |
| raise SystemExit("expected the scripted failure") | |
| except AssertionError: | |
| # shape of a JSON parse failure (001-03 run 20261029-202451): exception line, then an answer excerpt | |
| lab.fatal = ('Traceback (most recent call last):\n File "x.py", line 1, in f\n' | |
| 'json.decoder.JSONDecodeError: Unterminated string\n\nDuring handling of the above ' | |
| 'exception, another exception occurred:\n\nTraceback (most recent call last):\n' | |
| ' File "x.py", line 2, in g\nAssertionError: final message is not one JSON object ' | |
| '(Unterminated string); it ends with \'done.","}\'; see log\n{"verdict":"performed"') | |
| lab.failed_request = {"name": "lab"} | |
| assert used(ws) == 16 and lab.n_requests == 1 | |
| st = json.loads(json.dumps(lab.state())) | |
| lab2 = Lab(case, env, td, seed=0) | |
| lab2.restore(st) | |
| note = lab2.pending_notes[-1] | |
| assert "The failed check was: AssertionError: final message is not one JSON object" in note \ | |
| and 'done.","}' in note and '{"verdict"' not in note, note | |
| assert used(ws) == 1, f"calc_state not rolled back: used {used(ws)}" | |
| kept = list(td.glob("calc_state.discarded_request2_*")) | |
| assert len(kept) == 1 and json.loads((kept[0] / "lab.json").read_text())["used"] == 16, kept | |
| # resume after a committed request (actor crash, no fatal): nothing to roll back | |
| env.script = [(5, True)] | |
| lab2.call("lab", {"request": "req 2 again"}) | |
| st = json.loads(json.dumps(lab2.state())) | |
| Lab(case, env, td, seed=0).restore(st) | |
| assert used(ws) == 5, f"committed calc_state was changed: used {used(ws)}" | |
| class FlakyEnv(CalcEnv): | |
| """CalcEnv whose script entries may be 'net': the calculator ran, then the call died on a gateway error.""" | |
| def step(self, request, params, ledger, notes, noise): | |
| if self.script[0][1] == "net": | |
| used, _ = self.script.pop(0) | |
| self.write_turn(ledger, [], notes) | |
| (self.ws / "calc_state").mkdir(exist_ok=True) | |
| (self.ws / "calc_state" / "lab.json").write_text(json.dumps({"used": used})) | |
| raise AssertionError("claude exited 1; see log\nstdout: API Error: 500 litellm.InternalServerError: " | |
| "OpenAIException - Connection error.") | |
| self.notes_seen = list(notes) | |
| return super().step(request, params, ledger, notes, noise) | |
| def check_transient_env_retry(): | |
| """A lab request whose env call dies on a network/gateway error is retried in place (total cap | |
| LAB_REQUEST_TOTAL_S): calc_state goes back to before the request, the env gets a DISCARDED note, the request is | |
| committed once; a non-transient failure still propagates on the first attempt.""" | |
| import twinlab.lab as labmod | |
| case = Case(ROLLBACK_CASE, "case") | |
| used = lambda ws: json.loads((ws / "calc_state" / "lab.json").read_text())["used"] # noqa: E731 | |
| pause = labmod.LAB_RETRY_PAUSE_S | |
| labmod.LAB_RETRY_PAUSE_S = 0 | |
| try: | |
| with tempfile.TemporaryDirectory() as td: | |
| td = Path(td) | |
| ws = td / "env_ws" | |
| ws.mkdir() | |
| (ws / "session_record.md").write_text("") | |
| env = FlakyEnv(ws, [(1, True), (9, "net"), (8, "net"), (2, True), (7, False)]) | |
| lab = Lab(case, env, td, seed=0) | |
| lab.call("lab", {"request": "req 1"}) | |
| lab.call("lab", {"request": "req 2"}) | |
| assert used(ws) == 2 and lab.n_requests == 2, (used(ws), lab.n_requests) | |
| assert sum("was DISCARDED" in n and "network/gateway" in n for n in env.notes_seen) == 2, env.notes_seen | |
| assert len(list(td.glob("calc_state.discarded_request2_*"))) == 2 | |
| try: | |
| lab.call("lab", {"request": "req 3"}) | |
| raise SystemExit("expected the scripted non-transient failure to propagate") | |
| except AssertionError as e: | |
| assert "scripted environment failure" in str(e) and lab.n_requests == 2 | |
| finally: | |
| labmod.LAB_RETRY_PAUSE_S = pause | |
| class OutboxEnv(FakeEnv): | |
| """Writes a file into env_ws/outbox like a calculator export, then answers or fails a check.""" | |
| def step(self, request, params, ledger, notes, noise): | |
| name, ok = self.script.pop(0) | |
| self.write_turn(ledger, [], notes) | |
| if name: | |
| (self.ws / "outbox" / "export").mkdir(parents=True, exist_ok=True) | |
| (self.ws / "outbox" / "export" / name).write_text(name) | |
| assert ok, "scripted environment failure after the calculator ran" | |
| return answer(action_types=["inspect"]) | |
| def check_outbox_delivery(): | |
| """Files a calculator puts in env_ws/outbox reach the actor workspace after an accepted request and are listed in | |
| the result; a request that never committed delivers nothing (twinlab.lab outbox, 074, 2026-10-29).""" | |
| case = Case(ROLLBACK_CASE, "case") | |
| with tempfile.TemporaryDirectory() as td: | |
| td = Path(td) | |
| ws = td / "env_ws" | |
| ws.mkdir() | |
| (ws / "session_record.md").write_text("") | |
| (td / "actor_workspace").mkdir() | |
| env = OutboxEnv(ws, [("a.zip", True), (None, True), ("b.zip", False), ("c.zip", True)]) | |
| lab = Lab(case, env, td, seed=0) | |
| r = lab.call("lab", {"request": "export 1"})["content"][0]["text"] | |
| assert (td / "actor_workspace/export/a.zip").read_text() == "a.zip" and "- export/a.zip (5 bytes)" in r, r | |
| assert not (ws / "outbox").exists() | |
| r = lab.call("lab", {"request": "nothing"})["content"][0]["text"] | |
| assert "FILES DELIVERED" not in r, r | |
| try: | |
| lab.call("lab", {"request": "export 2"}) | |
| raise SystemExit("expected the scripted failure") | |
| except AssertionError: | |
| lab.fatal, lab.failed_request = "AssertionError: scripted", {"name": "lab"} | |
| st = json.loads(json.dumps(lab.state())) | |
| lab2 = Lab(case, env, td, seed=0) | |
| lab2.restore(st) | |
| assert not (ws / "outbox").exists() and not (td / "actor_workspace/export/b.zip").exists() | |
| assert len(list(td.glob("outbox.discarded_request3_*"))) == 1 | |
| r = lab2.call("lab", {"request": "export 2 again"})["content"][0]["text"] | |
| assert (td / "actor_workspace/export/c.zip").exists() and "export/c.zip" in r and "b.zip" not in r, r | |
| PER_ITEM_CASE = ROOT / "cases/045-oyster-family-heat-03/case.yaml" # challenge: cost 1, per_item | |
| PER_REQUEST_CASE = ROOT / "cases/001-coral-lcm-porites-03/case.yaml" # library_prep: cost 1.5, per request | |
| QUESTION_CASE = ROOT / "cases/045-oyster-family-heat-03/case.yaml" # challenge: cost 1, per_item | |
| def billing_lab(case_path, td, script): | |
| case = Case(case_path, "case") | |
| ws = td / "env_ws" | |
| ws.mkdir() | |
| (ws / "session_record.md").write_text("") | |
| return Lab(case, FakeEnv(ws, script), td, seed=0) | |
| def ledger_records(td): | |
| return [json.loads(x) for x in (td / "lab_ledger.jsonl").read_text().splitlines()] | |
| def check_charge_line_billing(): | |
| """The Lab bills from the calculator's CHARGE lines in the environment transcript (2026-10-29): a per-item action | |
| the env listed once for a run of nine groups costs nine (045-03 run 20261029-214420), a per-request action run | |
| twice in one request costs once (001-01 run 20261027-043031, rule 10), one actor question = one CHARGE line costs | |
| once even if the env lists it twice (070-01 run 20261026-074442), and a request without billable CHARGE lines | |
| keeps the env's listing.""" | |
| run9 = ("python3 calculators.py run --challenge H4 --families all", "H4 set up: 9 groups\nCHARGE: challenge x9") | |
| with tempfile.TemporaryDirectory() as td: | |
| td = Path(td) | |
| lab = billing_lab(PER_ITEM_CASE, td, [ | |
| (answer(action_types=["challenge"]), [run9]), # env under-lists | |
| (answer(action_types=["challenge"] * 9), [run9]), # env right | |
| (answer(action_types=["challenge"]), [run9, ("python3 calculators.py run --challenge H2 --families A,B", | |
| "CHARGE: challenge x2")]), # two runs add up: 11 | |
| (answer(action_types=["inspect"]), [("python3 calculators.py results --challenge H4", | |
| "rows\nCHARGE: inspect x1")]), # free only | |
| ]) | |
| costs = [] | |
| for i in range(4): | |
| lab.call("lab", {"request": f"req {i + 1}"}) | |
| costs.append(lab.cost_used) | |
| assert costs == [9, 18, 29, 29], costs | |
| recs = ledger_records(td) | |
| assert recs[0]["billing_from_charge_lines"] == {"env_listed": ["challenge"], "charge_lines": {"challenge": 9}} | |
| assert recs[0]["env"]["action_types"] == ["challenge"] * 9, recs[0]["env"]["action_types"] | |
| assert "billing_from_charge_lines" not in recs[1] and "billing_from_charge_lines" not in recs[3], recs[1] | |
| with tempfile.TemporaryDirectory() as td: | |
| td = Path(td) | |
| lab = billing_lab(PER_ITEM_CASE, td, [(answer(action_types=["challenge"]), [run9]), answer()]) | |
| lab.call("lab", {"request": "run"}) | |
| lab.call("lab", {"request": "next"}) | |
| assert any("Request #1 was billed from the calculator's CHARGE lines {'challenge': 9}" in x | |
| for x in lab.env.notes_seen), lab.env.notes_seen | |
| with tempfile.TemporaryDirectory() as td: # per-request action in two runs: once (rule 10) | |
| td = Path(td) | |
| prep = lambda s: (f"python3 calculators.py prep --setting {s}", "library done\nCHARGE: library_prep x1") # noqa: E731 | |
| lab = billing_lab(PER_REQUEST_CASE, td, [ | |
| (answer(action_types=["library_prep"], consumed=[{"item": "library_preps", "n": 2}]), [prep("a"), prep("b")]), | |
| ]) | |
| lab.call("lab", {"request": "two library preps"}) | |
| assert lab.cost_used == 1.5 and "billing_from_charge_lines" not in ledger_records(td)[0], lab.cost_used | |
| with tempfile.TemporaryDirectory() as td: # one multi-topic question = one call = one charge (070-01) | |
| td = Path(td) | |
| ask = ("python3 calculators.py ask --topic cleaning,gap", "HAOYU (cleaning): x\nHAOYU (gap): y\nCHARGE: challenge x1") | |
| lab = billing_lab(QUESTION_CASE, td, [(answer(action_types=["challenge", "challenge"]), [ask])]) | |
| lab.call("lab", {"request": "one question on two topics"}) | |
| assert lab.cost_used == 1, lab.cost_used | |
| with tempfile.TemporaryDirectory() as td: # no billable CHARGE line (calculators without them): env listing | |
| td = Path(td) | |
| lab = billing_lab(PER_ITEM_CASE, td, [(answer(action_types=["challenge"] * 3), [("cat notes.md", "notes")])]) | |
| lab.call("lab", {"request": "no calculator"}) | |
| assert lab.cost_used == 3, lab.cost_used | |
| with tempfile.TemporaryDirectory() as td: # session_record.md CHARGE lines are not billed again when the env | |
| td = Path(td) # tails the record in a calculator command (047-02 233832 #15) | |
| lab = billing_lab(PER_ITEM_CASE, td, [(answer(action_types=["challenge"] * 9, observation="H4\nCHARGE: challenge x9", | |
| grounding="ran it\n CHARGE: challenge x9"), [run9])]) | |
| lab.call("lab", {"request": "run"}) | |
| rec = (td / "env_ws" / "session_record.md").read_text() | |
| # the observation's CHARGE line is cut before the actor sees it (2026-11-04), the grounding's is recorded | |
| assert rec.count("recorded CHARGE: challenge x9") == 1 and "\nCHARGE:" not in rec, rec | |
| assert lab.pending_notes and "billing line" in lab.pending_notes[-1], lab.pending_notes | |
| tail2 = ("tail -5 session_record.md; python3 calculators.py run --challenge H2 --families A,B", | |
| rec + "\nH2 set up\nCHARGE: challenge x2") | |
| lab.env.script.append((answer(action_types=["challenge"] * 2), [tail2])) | |
| lab.call("lab", {"request": "run H2"}) | |
| assert lab.cost_used == 11, lab.cost_used | |
| assert "billing_from_charge_lines" not in ledger_records(td)[1], ledger_records(td)[1] | |
| from twinlab.env_check import charges_from_outputs | |
| tagged = ["CHARGE: question x1 [once per request]", "CHARGE: question x1 [once per request]"] | |
| assert charges_from_outputs(tagged, {"question"}, "t") == {"question": 1} | |
| assert charges_from_outputs(["CHARGE: a x2, b x3", "CHARGE: a x1"], {"a", "b"}, "t") == {"a": 3, "b": 3} | |
| assert charges_from_outputs(["CHARGE: a x2", "CHARGE: none"], set(), "t") == {"a": 1} | |
| # anchored at the line start (2026-10-30): a printed docstring's mid-line charge text is not billed (004-02 | |
| # 20261029-234203 #1), a real line (also indented) is, and `uniq -c` prefixes are not read | |
| doc = " quote --actions <k1,k2> lab hours of the named steps only (CHARGE: quote x1, cost 0)" | |
| assert charges_from_outputs([doc], {"quote"}, "t") == {}, "docstring charge text was billed" | |
| assert charges_from_outputs([doc + "\nCHARGE: quote x1\n CHARGE: read x2"], {"read"}, "t") == {"quote": 1, "read": 2} | |
| assert charges_from_outputs([" 42 CHARGE: modify_wells x1"], {"modify_wells"}, "t") == {} | |
| from twinlab.env_check import filtered_calculator_commands | |
| cmds = ["cd ws && python3 calculators.py run --x 1 2>&1 | grep -v '^#'", # filtered | |
| "python3 calculators.py run --x 1 | uniq -c", # filtered | |
| "python3 calculators.py run --x 1 > out.txt", # redirected | |
| "for p in A B; do timeout 60 python3 calculators.py t --p $p; done | grep x", # loop output filtered | |
| "python3 calculators.py run --x 1 2>&1", "python3 calculators.py a || true", # not filtered | |
| "tail -3 session_record.md | cut -c1-80; python3 calculators.py read --p A", # pipe on another command | |
| "python3 calculators.py take --spec '{\"L\": \"X|Y\"}' && python3 calculators.py b", # quoted | | |
| "cat notes.md | grep x", "grep -n RECORD calculators.py | head"] # no calculator invocation | |
| assert filtered_calculator_commands(cmds) == cmds[:4], filtered_calculator_commands(cmds) | |
| with tempfile.TemporaryDirectory() as td: # filtered output: bill max(env listing, CHARGE lines) per key | |
| td = Path(td) | |
| grep9 = ("python3 calculators.py run --challenge H4 --families all | grep set", "H4 set up: 9 groups") | |
| piped2 = ("python3 calculators.py run --challenge H2 --families A,B | tail -3", "CHARGE: challenge x2") | |
| lab = billing_lab(PER_ITEM_CASE, td, [ | |
| (answer(action_types=["challenge"] * 9), [grep9]), # grep dropped the CHARGE line: listing 9 | |
| (answer(action_types=["challenge"]), [piped2]), # listing 1 < CHARGE 2: 2 | |
| (answer(action_types=["challenge"] * 3), [piped2]), # listing 3 > CHARGE 2: 3 | |
| answer(), | |
| ]) | |
| costs = [] | |
| for i in range(4): | |
| lab.call("lab", {"request": f"req {i + 1}"}) | |
| costs.append(lab.cost_used) | |
| assert costs == [9, 11, 14, 14], costs | |
| recs = ledger_records(td) | |
| assert recs[0]["billing_from_charge_lines"]["filtered_commands"] == [grep9[0]], recs[0] | |
| assert recs[1]["billing_from_charge_lines"]["billed_max_of_listing_and_charge_lines"] == {"challenge": 2} | |
| assert "filtered_commands" in recs[2]["billing_from_charge_lines"], recs[2] | |
| assert any("Request #3 ran calculator commands through pipes" in x for x in lab.env.notes_seen), \ | |
| lab.env.notes_seen | |
| def check_resume_after_kill_billing(): | |
| """A run stopped inside request #2 without a fatal error (process killed): the resubmitted request #2 is billed | |
| from its own CHARGE lines only, not also from the interrupted attempt's (twinlab.lab restore, 2026-11-03).""" | |
| run9 = ("python3 calculators.py run --challenge H4 --families all", "H4 set up: 9 groups\nCHARGE: challenge x9") | |
| run2 = ("python3 calculators.py run --challenge H2 --families A,B", "H2 set up\nCHARGE: challenge x2") | |
| with tempfile.TemporaryDirectory() as td: | |
| td = Path(td) | |
| lab = billing_lab(PER_ITEM_CASE, td, [(answer(action_types=["challenge"] * 9), [run9])]) | |
| lab.call("lab", {"request": "run H4"}) | |
| assert lab.cost_used == 9, lab.cost_used | |
| lab.save_state() | |
| # request #2 starts (snapshot taken, env runs the calculator), then the process dies: no commit, no fatal | |
| lab.snapshot_calc_state(2) | |
| lab.env.write_turn(lab.ledger(), [run2], []) | |
| st = json.loads(lab.state_path.read_text()) | |
| assert st["fatal"] is None and st["n_requests"] == 1, st | |
| lab2 = Lab(lab.case, lab.env, td, seed=0) | |
| lab2.restore(st) | |
| assert any("request #2 was DISCARDED" in x for x in lab2.pending_notes), lab2.pending_notes | |
| lab2.env.script = [(answer(action_types=["challenge"] * 2), [run2])] | |
| lab2.call("lab", {"request": "run H2 again"}) | |
| assert lab2.cost_used == 11, f"interrupted attempt billed again: cost {lab2.cost_used}" | |
| assert "billing_from_charge_lines" not in ledger_records(td)[-1], ledger_records(td)[-1] | |
| HIDDEN_CASE = ROOT / "cases/038-orau-ultrafiltration-02/case.yaml" # actor_hidden_params: rinse_test.cleaning, ... | |
| def check_lab_limitation_notice(): | |
| """LAB LIMITATION notice: full text also after other output, options for catalog parameters only, hidden | |
| parameter names and values never shown (2026-11-03).""" | |
| case = Case(HIDDEN_CASE, "case") | |
| hidden = case.d["harness"]["actor_hidden_params"][0] | |
| visible = next(iter(case.catalog_for_actor())) | |
| lim = lambda p: {"parameter": p, "requested": "off-menu value Z", "used": "", "mode": "lab_limitation", # noqa: E731 | |
| "sample": "all"} | |
| with tempfile.TemporaryDirectory() as td: | |
| td = Path(td) | |
| ws = td / "env_ws" | |
| ws.mkdir() | |
| (ws / "session_record.md").write_text("") | |
| lab = Lab(case, FakeEnv(ws, [answer(observation="obs text", parameter_resolution=[lim(visible), lim(hidden)]), | |
| answer(verdict="not_simulatable", observation="", | |
| parameter_resolution=[lim(visible)])]), td, seed=0) | |
| t = lab.call("lab", {"request": "both"})["content"][0]["text"] | |
| tail = ("is not available in this lab; nothing was done or consumed for that step. Available options: " | |
| f"{case.catalog_for_actor()[visible]}") | |
| assert f"obs text\n\nLAB LIMITATION (not an experimental result): {visible} = off-menu value Z {tail}" in t, t | |
| assert ("\n\nLAB LIMITATION (not an experimental result): this setting = off-menu value Z is not available " | |
| "in this lab; nothing was done or consumed for that step. This setting has no option list in " | |
| "lab_catalog.") in t, t | |
| assert hidden not in t and hidden.split(".", 1)[1] not in t and "[]" not in t, t | |
| for v in case.menu_index()[hidden]["values"]: | |
| assert v not in t, f"hidden value {v!r} shown" | |
| t = lab.call("lab", {"request": "only limited"})["content"][0]["text"] | |
| assert t.endswith(f"\n\nLAB LIMITATION (not an experimental result): {visible} = off-menu value Z {tail}"), t | |
| def check_provenance_lines_cut(): | |
| """Calculator provenance lines the env copied into an observation are cut before the leak check (084-01 run | |
| 20261103-072629 #1); a mid-line copy still stops the request; the generic leak word spares parameter keys such | |
| as dnase_source (003).""" | |
| with tempfile.TemporaryDirectory() as td: | |
| td = Path(td) | |
| obs = "PACKAGE P1: Kestrel x 3\n _source recorded: campaign log and roll table\nrows 77" | |
| lab = billing_lab(PER_ITEM_CASE, td, [answer(observation=obs), answer(observation="next"), | |
| answer(observation="value 3 (_source recorded: log)")]) | |
| t = lab.call("lab", {"request": "r1"})["content"][0]["text"] | |
| assert "PACKAGE P1: Kestrel x 3\nrows 77" in t and "_source" not in t, t | |
| assert ledger_records(td)[0]["env"]["stripped_provenance_lines"] == [" _source recorded: campaign log and roll table"] | |
| lab.call("lab", {"request": "r2"}) | |
| assert any("provenance line" in x for x in lab.env.notes_seen), lab.env.notes_seen | |
| try: | |
| lab.call("lab", {"request": "r3"}) | |
| raise SystemExit("expected the leak check to stop a mid-line provenance copy") | |
| except AssertionError as e: | |
| assert "'_source'" in str(e), e | |
| from twinlab.lab import GENERIC_LEAK | |
| generic = re.compile(GENERIC_LEAK, re.I) # the generic part alone (045-01 also lists '_source' itself) | |
| assert generic.search("column_cleanup.dnase_source = old kit; vortex_source true") is None | |
| assert generic.search("value 3 (_source recorded: log)") is not None | |
| def check_partial_without_items_relabelled(): | |
| """partially_performed with no not_performed_items (031-02 run 20261014-124236 #19 aborted the run) is relabelled | |
| performed and recorded in the ledger; with nothing done and nothing reported it still stops (2026-11-04).""" | |
| run1 = ("python3 calculators.py run --challenge H4 --families A", "H4 set up: 1 group\nCHARGE: challenge x1") | |
| with tempfile.TemporaryDirectory() as td: | |
| td = Path(td) | |
| lab = billing_lab(PER_ITEM_CASE, td, [ | |
| (answer(verdict="partially_performed", action_types=["challenge"], observation="all done"), [run1]), | |
| answer(verdict="partially_performed", observation=" ")]) | |
| t = lab.call("lab", {"request": "r1"})["content"][0]["text"] | |
| rec = ledger_records(td)[0] | |
| assert rec["env"]["verdict"] == "performed" and rec["cost"] == 1, rec | |
| assert rec["env"]["verdict_relabelled"] == "partially_performed -> performed (no not_performed_items)", rec | |
| assert "all done" in t and MESSAGES["not_performed"] not in t, t | |
| try: | |
| lab.call("lab", {"request": "r2"}) | |
| raise SystemExit("expected a stop: partially_performed with nothing done and nothing reported") | |
| except AssertionError as e: | |
| assert "no not_performed_items, no action_types and no observation" in str(e), e | |
| def check_lost_output_flags(): | |
| """An observation cut off with an ellipsis, and a billed calculator output whose decimals do not reach the | |
| observation (087-02 replay 20261103-141338 #1), are flagged in the ledger record (no retry) and by | |
| output_problems for check_env; a complete observation is not flagged (2026-11-04).""" | |
| from twinlab.env_check import output_problems | |
| refine = ("python3 calculators.py run --challenge H4 --families A", | |
| "RESULT A: mortality 0.42, 0.37\nguest-guest distances: C17-C18 1.36, C18-C19 1.36\n" | |
| " _source recorded: x 9.99\nCHARGE: challenge x1") | |
| nmr = ("python3 calculators.py run --challenge H2 --families B", "NMR ratio 1 : 0.16\nCHARGE: challenge x1") | |
| with tempfile.TemporaryDirectory() as td: | |
| td = Path(td) | |
| lab = billing_lab(PER_ITEM_CASE, td, [ | |
| (answer(action_types=["challenge"] * 2, | |
| observation="RESULT A: mortality 0.42, 0.37\ndistances: C17-C18 1.36, C17-C19 ... "), | |
| [refine, nmr]), | |
| (answer(action_types=["challenge"] * 2, | |
| observation="mortality 0.42, 0.37; C17-C18 1.36, C18-C19 1.36; NMR 1 : 0.16"), [refine, nmr])]) | |
| lab.call("lab", {"request": "cut"}) | |
| lab.call("lab", {"request": "complete"}) | |
| recs = ledger_records(td) | |
| kinds = [p["kind"] for p in recs[0]["env"]["output_flags"]] | |
| assert kinds == ["observation_truncated", "billed_output_unreported"], recs[0]["env"]["output_flags"] | |
| assert "0.16" in recs[0]["env"]["output_flags"][1]["what"], recs[0]["env"]["output_flags"] | |
| assert "output_flags" not in recs[1]["env"], recs[1]["env"] | |
| assert recs[0]["cost"] == 2, recs[0] # flag only: billing unchanged | |
| # free CHARGE lines and integer-only outputs are not result checks; numbers from the request text do not count | |
| assert output_problems(["DAY 6\nCHARGE: challenge x1", "q 0.5\nCHARGE: inspect x1"], "ok", "r") == [] | |
| assert output_problems(["set 0.003 run\nCHARGE: challenge x1"], "ok", "amplitude 0.003") == [] | |
| assert output_problems([], "fine …", "r")[0]["kind"] == "observation_truncated" | |
| GUARD_FAKE_CALC = '''import json, sys | |
| from pathlib import Path | |
| st = Path("calc_state"); st.mkdir(exist_ok=True) | |
| f = st / "n.json"; n = json.loads(f.read_text())["n"] if f.exists() else 0 | |
| cmd = sys.argv[1] | |
| if cmd == "grow": | |
| f.write_text(json.dumps({"n": n + 1})); print(f"grown {n + 1} OD 0.731"); print("CHARGE: grow x1") | |
| elif cmd == "status": | |
| print(f"vials used {n}") | |
| elif cmd == "quote": | |
| print("quote 2.5 h"); print("CHARGE: inspect x1") | |
| ''' | |
| class GuardEnv(FakeEnv): | |
| """FakeEnv of a guarded run: a script entry may carry guard log records the calculator guard wrote.""" | |
| def step(self, request, params, ledger, notes, noise): | |
| entry = self.script[0] | |
| if isinstance(entry, tuple) and len(entry) == 3: | |
| self.script[0] = entry[:2] | |
| with self.guard_log.open("a") as f: | |
| f.write("".join(json.dumps(r) + "\n" for r in entry[2])) | |
| return super().step(request, params, ledger, notes, noise) | |
| def check_benchmark_name_guard(): | |
| """The benchmark's own name is blocked in any spelling: the guard hook denies the search and | |
| withholds tool output, and the post-run audit flags tool results but not the actor's own text.""" | |
| from twinlab.actors import guard | |
| from twinlab.judge import audit_actor | |
| case = Case(ROLLBACK_CASE, "case") | |
| assert "TwinLab-Bench" in case.guard_needles and "twinlab bench" in case.guard_needles | |
| assert case_name("002-resazurin-clam-02") == "resazurin-clam" and case_name("007-resazurin-oyster-02-xp-01") == "resazurin-oyster" | |
| assert case_name(case.id) in case.guard_needles | |
| with tempfile.TemporaryDirectory() as td: | |
| hooks = Path(td) / "hooks" | |
| guard.install(hooks, case) | |
| def hook(ev: dict) -> str: | |
| return subprocess.run([sys.executable, str(hooks / guard.HOOK_FILE)], input=json.dumps(ev), | |
| capture_output=True, text=True, check=True).stdout | |
| pre = {"hook_event_name": "PreToolUse", "tool_name": "WebSearch"} | |
| out = hook({**pre, "tool_input": {"query": "twinlab-bench dataset answers"}}) | |
| assert json.loads(out)["hookSpecificOutput"]["permissionDecision"] == "deny", out | |
| assert hook({**pre, "tool_input": {"query": "qubit assay linear range"}}) == "" | |
| post = hook({"hook_event_name": "PostToolUse", "tool_name": "WebFetch", "tool_input": {}, | |
| "tool_response": {"text": "code at huggingface.co/datasets/x/TwinLab-Bench"}}) | |
| assert "withheld" in json.loads(post)["hookSpecificOutput"]["updatedToolOutput"]["text"], post | |
| run = Path(td) / "run" | |
| run.mkdir() | |
| (run / "run_config.json").write_text(json.dumps({"actor_agent": "claude-code"})) | |
| stream = run / "actor_stream_r0_0.jsonl" | |
| own = {"type": "assistant", "message": {"content": [{"type": "text", "text": "maybe a TwinLab-Bench task"}]}} | |
| stream.write_text(json.dumps(own) + "\n") | |
| assert not audit_actor(case, run)["contaminated"] | |
| result = {"type": "user", "message": {"content": [{"type": "tool_result", "content": "found TwinLab_Bench"}]}} | |
| stream.write_text(json.dumps(result) + "\n") | |
| assert audit_actor(case, run)["contaminated"] | |
| # a request alone is not contamination; the third stopped request is | |
| call = {"type": "assistant", "message": {"content": [{"type": "tool_use", "name": "WebSearch", | |
| "input": {"query": "TwinLab-Bench answers"}}]}} | |
| stream.write_text(json.dumps(call) + "\n") | |
| log = run / "actor_config/hooks/guard.log" | |
| log.parent.mkdir(parents=True) | |
| for n_blocked, expected in ((0, False), (2, False), (3, True)): | |
| log.write_text("".join(json.dumps({"tool": "WebSearch", "blocked": True}) + "\n" for _ in range(n_blocked))) | |
| a = audit_actor(case, run) | |
| assert a["contaminated"] is expected and a["n_blocked_attempts"] == n_blocked, a | |
| def check_calc_guard(): | |
| """twinlab/calc_guard.py (2026-11-04, 044-01 replays 025345/025709 `grow --lines F01 >/dev/null 2>&1; echo skip`): | |
| a calculator run whose whole stdout goes to /dev/null and that prints a billable CHARGE line is refused before it | |
| counts (calc_state restored, CHARGE line never printed, refusal text in the shell's own output); free runs with | |
| /dev/null, pipes into head, --help and plain runs are untouched. Run through check_env's replay_command (the same | |
| guarded PATH a run uses). In the Lab the refused command is neither billed nor treated as a filtered command, the | |
| plain rerun is billed once, and the guard record goes into the ledger.""" | |
| from twinlab import calc_guard | |
| from twinlab.env_check import CHARGE_RE, replay_command | |
| with tempfile.TemporaryDirectory(dir=ROOT / "tmp") as td: # not under /tmp: replay_command binds nothing here | |
| run = Path(td) | |
| ws = run / "env_ws" | |
| ws.mkdir() | |
| (ws / "calculators.py").write_text(GUARD_FAKE_CALC) | |
| calc_guard.install(run) | |
| glog = run / "env_guard_replay.jsonl" # replay_command's guard log (ws.parent) | |
| used = lambda: json.loads((ws / "calc_state/n.json").read_text())["n"] if (ws / "calc_state/n.json").exists() else 0 # noqa: E731 | |
| sh = lambda c: replay_command(c, ws, ws) # noqa: E731 | |
| out = sh("python3 calculators.py grow --lines F01 >/dev/null 2>&1; echo skip") | |
| assert calc_guard.REFUSAL_MARK in out and "skip" in out and "grow x1" in out, out | |
| assert CHARGE_RE.search(out) is None and "0.731" not in out, out | |
| assert used() == 0 and not (ws / "calc_state").exists(), "refused run changed calc_state" | |
| rec = json.loads(glog.read_text().splitlines()[-1]) | |
| assert rec["decision"].startswith("refused") and rec["billed"] == ["grow x1"], rec | |
| out = sh("python3 calculators.py grow; python3 calculators.py status >/dev/null; echo ok") | |
| assert "CHARGE: grow x1" in out and calc_guard.REFUSAL_MARK not in out and used() == 1, out | |
| assert json.loads(glog.read_text().splitlines()[-1])["decision"].startswith("passed"), glog.read_text() | |
| out = sh("python3 calculators.py quote &>/dev/null; echo q") # free CHARGE key: passes | |
| assert calc_guard.REFUSAL_MARK not in out, out | |
| n_log = len(glog.read_text().splitlines()) | |
| out = sh("python3 calculators.py grow | head -5; python3 calculators.py --help >/dev/null; python3 -c 'print(7)'") | |
| assert "CHARGE: grow x1" in out and used() == 2 and calc_guard.REFUSAL_MARK not in out, out | |
| assert len(glog.read_text().splitlines()) == n_log, "pipes, --help and -c must not reach the guard's check" | |
| out = sh("for i in 1 2; do python3 calculators.py grow; done >/dev/null; echo loop") | |
| assert out.count(calc_guard.REFUSAL_MARK) == 2 and used() == 2, out | |
| # Lab: refused attempt + plain rerun in one request | |
| refused_out = ("\nLAB HARNESS REFUSED this command and did not run it: `python3 calculators.py run --challenge H4 " | |
| "--families A` performs a billed lab action (challenge x1) ...\nskip") | |
| with tempfile.TemporaryDirectory() as td: | |
| td = Path(td) | |
| case = Case(PER_ITEM_CASE, "case") | |
| ws = td / "env_ws" | |
| ws.mkdir() | |
| (ws / "session_record.md").write_text("") | |
| rec = {"command": "python3 calculators.py run --challenge H4 --families A", "billed": ["challenge x1"], | |
| "decision": "refused (billed action with discarded output; state restored, nothing billed)"} | |
| env = GuardEnv(ws, [(answer(action_types=["challenge"], observation="mortality 0.42"), | |
| [("python3 calculators.py run --challenge H4 --families A >/dev/null 2>&1; echo skip", | |
| refused_out), | |
| ("python3 calculators.py run --challenge H4 --families A", | |
| "RESULT A: mortality 0.42\nCHARGE: challenge x1")], [rec])]) | |
| env.extra_env = {"PATH": "guarded"} | |
| lab = Lab(case, env, td, seed=0) | |
| lab.call("lab", {"request": "run H4 on A"}) | |
| r = ledger_records(td)[0] | |
| assert r["cost"] == 1 and "billing_from_charge_lines" not in r, r | |
| assert r["env"]["guard_discarded_output_runs"] == [rec], r["env"] | |
| assert not any("pipes or filters" in x for x in lab.pending_notes), lab.pending_notes | |
| def check_json_answer_forms(): | |
| """Env/judge final message forms accepted by twinlab.claude_cli.parse_json_answer: bare object, one fenced block, | |
| prose then object, prose then one fenced block (069-02, 2026-10-29), any of these plus stray closing braces | |
| (003-03 judge, 2026-10-29); anything else fails.""" | |
| from twinlab.claude_cli import parse_json_answer | |
| schema = {"type": "object", "required": ["a"]} | |
| obj = '{"a": 1, "b": "x {y}"}' | |
| for text in (obj, f"```json\n{obj}\n```", f"Nothing could be done.\n\n{obj}", | |
| f"Nothing could be done. Nothing was charged.\n\n```json\n{obj}\n```", | |
| f"{obj}\n}}", f"{obj}}}]", f"```json\n{obj}\n```\n}}", f"Nothing could be done.\n\n{obj}\n}}"): | |
| assert parse_json_answer({"result": text}, schema, Path("-")) == {"a": 1, "b": "x {y}"}, text | |
| for text in (f"{obj}\nmore", f"{obj}\n}}\nThe score is 9.", f"{obj}}} done",f"Note {{x}}.\n```json\n{obj}\n```", f"x\n```json\n{obj}\n```\ntrailing"): | |
| try: | |
| parse_json_answer({"result": text}, schema, Path("-")) | |
| raise SystemExit(f"accepted {text!r}") | |
| except AssertionError: | |
| pass | |
| # a malformed tail is named on the error's first line (001-03 run 20261029-202451 ended '...","}') | |
| try: | |
| parse_json_answer({"result": '{"a": 1, "g": "done.","}'}, schema, Path("-")) | |
| raise SystemExit("accepted a dangling key") | |
| except AssertionError as e: | |
| assert str(e).splitlines()[0].count('done.","}') == 1, str(e) | |
| def open_objects(schema, where="root"): | |
| """Paths of objects in a JSON schema that list properties but are not closed (additionalProperties false).""" | |
| bad = [] | |
| if isinstance(schema, list): | |
| for i, x in enumerate(schema): | |
| bad += open_objects(x, f"{where}[{i}]") | |
| elif isinstance(schema, dict): | |
| if "properties" in schema and schema.get("additionalProperties") is not False: | |
| bad.append(where) | |
| for k, v in schema.items(): | |
| if k == "properties": | |
| for pk, pv in v.items(): | |
| bad += open_objects(pv, f"{where}.{pk}") | |
| elif k not in ("required", "enum"): | |
| bad += open_objects(v, f"{where}.{k}") | |
| return bad | |
| def check_structured_answers(): | |
| """--json-schema answers (restored 2026-10-30): env and judge schemas closed at every level, structured_output | |
| re-validated and required, StructuredOutput rejections counted from transcript lines, and the env answer path | |
| chosen by the system prompt's marker (LEGACY text JSON for runs started 2026-10-26..10-30).""" | |
| import twinlab.env_agent as env_mod | |
| from twinlab.claude_cli import (STRUCTURED_ANSWER_MARK, json_answer_instructions, structured_answer, | |
| structured_output_rejections) | |
| from twinlab.judge import judge_schema | |
| case = Case(ROLLBACK_CASE, "case") | |
| js = judge_schema(case) | |
| assert not open_objects(js), open_objects(js) | |
| assert js["properties"]["rubric"]["additionalProperties"] is False | |
| # a closed schema rejects an extra key; a missing structured_output fails | |
| with tempfile.TemporaryDirectory() as td: | |
| td = Path(td) | |
| env = EnvAgent(case, td, "no-model", resume=False) | |
| assert not open_objects(env.schema), open_objects(env.schema) | |
| assert env.schema["properties"]["parameter_resolution"]["items"]["additionalProperties"] is False | |
| assert "additionalProperties" not in json.dumps(env.schema_open) | |
| assert structured_answer({"structured_output": answer()}, env.schema, Path("-")) == answer() | |
| for bad in ({"structured_output": dict(answer(), bash_note="x")}, {"structured_output": None}, | |
| {"result": json.dumps(answer())}): | |
| try: | |
| structured_answer(bad, env.schema, Path("-")) | |
| raise SystemExit(f"accepted {str(bad)[:80]}") | |
| except AssertionError: | |
| pass | |
| # rejections: a StructuredOutput tool_use (recorded twice, as the CLI does) rejected once, then accepted; | |
| # an is_error result of another tool does not count | |
| so = lambda i: {"type": "tool_use", "id": i, "name": "StructuredOutput", "input": {}} # noqa: E731 | |
| res = lambda i, err: {"type": "tool_result", "tool_use_id": i, "content": "Output does not match", # noqa: E731 | |
| "is_error": err} | |
| lines = [{"message": {"role": "assistant", "content": [so("a")]}}, | |
| {"type": "api-request-blob", "message": {"role": "assistant", "content": [so("a")]}}, | |
| {"message": {"role": "user", "content": [res("a", True)]}}, | |
| {"message": {"role": "assistant", "content": [{"type": "tool_use", "id": "b", "name": "Bash"}]}}, | |
| {"message": {"role": "user", "content": [res("b", True)]}}, | |
| {"message": {"role": "assistant", "content": [so("c")]}}, | |
| {"message": {"role": "user", "content": [res("c", False)]}}, {"type": "tools-used"}] | |
| assert structured_output_rejections([json.dumps(x) for x in lines]) == ["Output does not match"] | |
| calls = [] | |
| real_run = env_mod.run_claude_json_env | |
| def fake_run(args, cwd, timeout_s, log_path, tmp_dir, extra_env): | |
| # env calls carry the calculator guard's PATH (twinlab/calc_guard.py) for cases with a calculator | |
| assert extra_env["PATH"].startswith(str(Path(td) / "env_bin")), extra_env | |
| calls.append(args) | |
| out = {"usage": {"input_tokens": 1, "cache_read_input_tokens": 0, "cache_creation_input_tokens": 0}, | |
| "num_turns": 2} | |
| if "--json-schema" in args: | |
| return dict(out, result="", structured_output=answer()) | |
| return dict(out, result="```json\n" + json.dumps(dict(answer(), bash_note="x")) + "\n```") | |
| env_mod.run_claude_json_env = fake_run | |
| try: | |
| led = {"n_requests": 0} | |
| sp = env.system_prompt_file.read_text(encoding="utf-8") | |
| assert STRUCTURED_ANSWER_MARK in sp and env_mod.ANSWER_FORMAT_MARK not in sp and not env.legacy_text_json | |
| assert env.step("r", {}, led, [], []) == answer() | |
| a = calls[-1] | |
| assert json.loads(a[a.index("--json-schema") + 1]) == env.schema and "--session-id" in a | |
| assert a[1].endswith("Submit your answer with the StructuredOutput tool."), a[1][-200:] | |
| st = env.state() | |
| # resume of a structured run stays structured | |
| env2 = EnvAgent(case, td, "no-model", resume=True) | |
| env2.restore(st) | |
| assert not env2.legacy_text_json and env2.step("r", {}, led, [], []) == answer() | |
| assert "--json-schema" in calls[-1] and "--resume" in calls[-1] | |
| # resume of a LEGACY run (system prompt with # ANSWER FORMAT): text JSON, open schema, key-order line | |
| env.system_prompt_file.write_text(sp.split(STRUCTURED_ANSWER_MARK)[0] + json_answer_instructions( | |
| env.schema_open), encoding="utf-8") | |
| env3 = EnvAgent(case, td, "no-model", resume=True) | |
| env3.restore(st) | |
| assert env3.legacy_text_json | |
| assert env3.step("r", {}, led, [], []) == dict(answer(), bash_note="x") | |
| assert "--json-schema" not in calls[-1] and "described under ANSWER FORMAT" in calls[-1][1] | |
| # neither marker (run started before 2026-10-26): not resumable | |
| env.system_prompt_file.write_text(sp.split(STRUCTURED_ANSWER_MARK)[0], encoding="utf-8") | |
| try: | |
| EnvAgent(case, td, "no-model", resume=True) | |
| raise SystemExit("resumed a run without an answer marker") | |
| except AssertionError: | |
| pass | |
| finally: | |
| env_mod.run_claude_json_env = real_run | |
| def check_score_rescale_100(): | |
| """0-100 scale (twinlab/scale.py): items x 100/M, total one decimal half-up, core missed -> 0.""" | |
| from types import SimpleNamespace | |
| from twinlab.judge import score | |
| from twinlab.scale import rescale | |
| def rub(**pts): | |
| return {k: {"points": v, "component": "conclusion"} for k, v in pts.items()} | |
| r85 = rub(A=3, B=2.5, C=3) # M = 8.5, core A | |
| s = rescale({"A": 2, "B": 2.5, "C": 3}, 7.5, r85, ["A"]) | |
| assert (s["max_native"], s["total_100"], s["derived_100"]) == (8.5, 88.2, 0), s | |
| s = rescale({"A": 3, "B": 2.5, "C": 3}, 8.5, r85, ["A"]) | |
| assert (s["total_100"], s["derived_100"], s["points_100"]) == (100.0, 100.0, {"A": 35.3, "B": 29.4, "C": 35.3}), s | |
| r1025 = rub(A=4, B=3.25, C=3) # M = 10.25 | |
| s = rescale({"A": 4, "B": 3.25, "C": 2.75}, 10.0, r1025, ["A"]) | |
| assert (s["total_100"], s["derived_100"]) == (97.6, 97.6), s # 97.5609... | |
| s = rescale({"A": 4, "B": 3.25, "C": 2.75}, 9.0, r1025, ["A"]) # one trap (-1) scaled by the same factor | |
| assert s["total_100"] == 87.8, s # 87.8048... | |
| s = rescale({"A": 4, "B": 0.5}, 0.5, rub(A=4, B=4), ["A"]) # 6.25 -> half-up 6.3, not banker's 6.2 | |
| assert s["total_100"] == 6.3, s | |
| # judge.score adds the 0-100 fields next to the native ones (unchanged) | |
| case = SimpleNamespace(scoring={"rubric": r85, "pass_rule": {"required_full": ["A"]}, | |
| "penalties": {"per_trap_triggered": -1, "consumable_overuse": []}}, | |
| consumables=[], initial_consumed={}, rubric_sha256="x", budget_unit="u") | |
| lab = SimpleNamespace(consumed={}, report={"x": 1}, cost_used=3.0, n_requests=2) | |
| flag = {"flag": False} | |
| j = {"rubric": {"A": {"points": 3}, "B": {"points": 2}, "C": {"points": 3}}, "traps": {"t": {"triggered": True}}, | |
| "env_leak": flag, "env_inconsistency": flag, "env_coverage_gap": flag} | |
| s = score(case, j, lab) | |
| assert (s["total"], s["pass"], s["max_native"], s["total_100"], s["derived_100"]) == (7, True, 8.5, 82.4, 82.4), s | |
| j["rubric"]["A"]["points"] = 2.5 | |
| s = score(case, j, lab) | |
| assert (s["total"], s["pass"], s["total_100"], s["derived_100"]) == (6.5, False, 76.5, 0), s | |
| def main(): | |
| verbose = "-v" in sys.argv | |
| check_score_rescale_100() | |
| print("PASS 0-100 score rescale (x 100/M, one decimal half-up, penalties scaled, core missed -> 0)", flush=True) | |
| check_json_answer_forms() | |
| print("PASS env/judge JSON answer forms (LEGACY text path)", flush=True) | |
| check_structured_answers() | |
| print("PASS structured answers (closed schemas, re-validation, rejection count, answer path by marker)", flush=True) | |
| check_resume_rollback() | |
| check_transient_env_retry() | |
| print("PASS resume rollback of calc_state", flush=True) | |
| check_outbox_delivery() | |
| print("PASS outbox delivery to the actor workspace", flush=True) | |
| check_charge_line_billing() | |
| print("PASS billing from CHARGE lines (per-item, per-request split, one question, no CHARGE, anchored, filtered, session_record)", flush=True) | |
| check_resume_after_kill_billing() | |
| print("PASS resume after a killed request bills the resubmission only", flush=True) | |
| check_lab_limitation_notice() | |
| print("PASS LAB LIMITATION notice (full text after output, catalog options only, hidden names not shown)", flush=True) | |
| check_provenance_lines_cut() | |
| print("PASS calculator provenance lines cut from observations, mid-line copies still stop", flush=True) | |
| check_partial_without_items_relabelled() | |
| print("PASS partially_performed without not_performed_items relabelled performed, empty one still stops", flush=True) | |
| check_lost_output_flags() | |
| print("PASS lost env output flagged (ellipsis end, billed decimals unreported), billing unchanged", flush=True) | |
| check_calc_guard() | |
| print("PASS calculator guard: billed run with /dev/null stdout refused before it counts, free/pipe/help untouched, " | |
| "Lab bills the plain rerun once", flush=True) | |
| check_benchmark_name_guard() | |
| print("PASS benchmark name: web search denied, tool output withheld, post-run audit flags it, own text ignored", flush=True) | |
| paths = [Path(p) for p in sys.argv[1:] if p != "-v"] or sorted((ROOT / "cases").glob("*/case.yaml")) | |
| failed = [] | |
| for p in paths: | |
| try: | |
| check(p, verbose) | |
| print(f"PASS {p.parent.name}", flush=True) | |
| except Exception as e: | |
| failed.append(p.parent.name) | |
| print(f"FAIL {p.parent.name}: {type(e).__name__}: {e}", flush=True) | |
| if verbose: | |
| traceback.print_exc() | |
| print(f"\n{len(paths) - len(failed)}/{len(paths)} cases pass" + (f"; failing: {failed}" if failed else "")) | |
| sys.exit(1 if failed else 0) | |
| if __name__ == "__main__": | |
| main() | |