File size: 6,193 Bytes
eeaa10a
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
"""Human baseline: a person plays the actor on a case through a terminal, against the same lab, environment agent,
budget, judge and scoring as the model actor.

python scripts/human_baseline.py --case cases/008-qpcr-polyic-02/case.yaml --tester T1 \
    --env-model claude-sonnet-5-5 --judge-model claude-opus-5-5 --out runs

Commands at the prompt:
  brief                      show the task brief again
  catalog                    list the lab's procedures and parameter options (same as the lab_catalog tool)
  status                     budget used/remaining and limited materials left (same as lab_status)
  lab                        submit ONE lab request; type the request, end with a line containing only "."
                             then optionally give parameters as JSON ({"procedure.param": ["value"]}) or leave empty
  schema                     show the fields of the final report
  report <file.json>         submit the final report from a JSON file with those fields (once; ends the session)
Images returned by the lab are saved under <run_dir>/human_images/ and their paths are printed.
The workspace with the case files is printed at start; analyse them with any tools you like.
"""
import argparse
import base64
import json
import sys
import time
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parents[1]))   # run from a checkout without installing
from twinlab.actors import HUMAN                    # noqa: E402
from twinlab.case import Case                       # noqa: E402
from twinlab.env_agent import EnvAgent              # noqa: E402
from twinlab.lab import Lab                         # noqa: E402
from twinlab.run import finish_run, run_config      # noqa: E402

END_OF_REQUEST = "."


def show(result: dict, img_dir: Path, n_img: list) -> None:
    for c in result["content"]:
        if c["type"] == "text":
            print(c["text"])
        else:
            assert c["type"] == "image", c["type"]
            n_img[0] += 1
            p = img_dir / f"img_{n_img[0]:03d}.jpg"
            p.write_bytes(base64.b64decode(c["data"]))
            print(f"[image saved] {p}")
    if result["isError"]:
        print("[error]")


def read_request() -> tuple:
    print(f'Request (end with a line containing only "{END_OF_REQUEST}"):')
    lines = []
    while True:
        line = input()
        if line.strip() == END_OF_REQUEST:
            break
        lines.append(line)
    raw = input("Parameters JSON (empty for none): ").strip()
    params = json.loads(raw) if raw else {}
    return "\n".join(lines).strip(), params


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--case", required=True, type=Path)
    ap.add_argument("--tester", required=True, help="anonymous tester label, e.g. T1")
    ap.add_argument("--env-model", required=True)
    ap.add_argument("--judge-model", required=True)
    ap.add_argument("--out", required=True, type=Path)
    a = ap.parse_args()
    case = Case(a.case, "case")
    run_dir = (a.out / case.id / f"human-{a.tester}-{time.strftime('%Y%m%d-%H%M%S')}" / "run_0").resolve()
    run_dir.mkdir(parents=True)
    cfg = run_config(case, 0, HUMAN, f"human:{a.tester}", a.env_model, a.judge_model, None, "case", None)
    (run_dir / "run_config.json").write_text(json.dumps(cfg, indent=1))
    (run_dir / "actor_state.json").write_text(json.dumps({"session_id": None, "invocations": []}, indent=1))
    env = EnvAgent(case, run_dir, a.env_model, resume=False)
    lab = Lab(case, env, run_dir, 0)
    ws = run_dir / "actor_workspace"
    case.write_actor_workspace(ws)
    brief = case.actor_prompt()
    (run_dir / "actor_prompt.md").write_text(brief, encoding="utf-8")
    img_dir = run_dir / "human_images"
    img_dir.mkdir()
    n_img = [0]
    session_log = run_dir / "human_session.jsonl"
    print(brief)
    print(f"\n=== Your case files: {ws}\n=== In this terminal the tools are commands: "
          "brief, catalog, status, lab, schema, report <file.json>. Type 'help' for details.")
    t0 = time.time()
    while lab.report is None:
        cmd = input("\nlab> ").strip()
        if not cmd:
            continue
        with open(session_log, "a", encoding="utf-8") as f:
            f.write(json.dumps({"t": time.time() - t0, "cmd": cmd}) + "\n")
        if cmd == "help":
            print(__doc__)
        elif cmd == "brief":
            print(brief)
        elif cmd == "catalog":
            show(lab.call("lab_catalog", {}), img_dir, n_img)
        elif cmd == "status":
            show(lab.call("lab_status", {}), img_dir, n_img)
        elif cmd == "schema":
            print(json.dumps(case.report_tool_schema(), indent=1))
        elif cmd == "lab":
            request, params = read_request()
            with open(session_log, "a", encoding="utf-8") as f:
                f.write(json.dumps({"t": time.time() - t0, "request": request, "parameters": params},
                                   ensure_ascii=False) + "\n")
            show(lab.call("lab", {"request": request, "parameters": params}), img_dir, n_img)
            lab.save_state()
            assert lab.fatal is None, f"environment error; see {run_dir}. Resume with scripts/resume_run.py is not " \
                                      f"supported for human runs yet. Error:\n{lab.fatal}"
        elif cmd.startswith("report "):
            report = json.loads(Path(cmd.split(" ", 1)[1].strip()).expanduser().read_text())
            missing = [k for k in case.report_tool_schema()["required"] if k not in report]
            if missing:
                print(f"[error] report is missing required fields {missing}; see 'schema'")
                continue
            show(lab.call("submit_final_report", report), img_dir, n_img)
        else:
            print("unknown command; type 'help'")
    lab.save_state()
    st = json.loads((run_dir / "actor_state.json").read_text())
    st["wall_time_s"] = round(time.time() - t0)
    (run_dir / "actor_state.json").write_text(json.dumps(st, indent=1))
    print("\nScoring (judge running)...")
    res = finish_run(case, run_dir, lab, cfg)
    print(json.dumps(res["score"], indent=1))


if __name__ == "__main__":
    main()