File size: 9,803 Bytes
fd8b1ae | 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 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 | """An agent with no model in it: answer every environment from its reference, through the harness proxy.
python3 run_reference.py --engine ENGINE --environments F --out DIR [--only id,id] [--direct]
For a tradeoff or chain_design environment it sends the reference passing and failing runs to the
verifier, hands each run to its solve through the task's coupling where the task has one, and writes
the card with the seals this verifier gives. For a budget environment it sends the two reference
requests. For a forensics table it puts the table to the verifier (each row's request as sent, up to
the task's budget) and names the false rows the build recorded.
Every call goes through harness/mcp_log_proxy.py, started in an empty working folder, so the
authoritative call record is DIR/<id>.harness.jsonl, as in a pass@k attempt. The same calls are also
written beside the reply, DIR/<id>.calls.jsonl. --direct talks to ENGINE with no proxy and writes the
reply-side log only.
python3 score.py DIR --engine ENGINE --environments F --calls-from harness
Licence: Apache-2.0.
"""
import argparse
import copy
import json
import os
import subprocess
import sys
import tempfile
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
import chainlib # noqa: E402
from score import (FREE_TOOLS, NOT_STOPPED, build_stage_request, close_verifier, continuation_of, design_shape, # noqa: E402
file_sha256, get_path, load_environments, open_verifier)
from ztp_mcp import McpError, StdioVerifier # noqa: E402
PROXY = os.path.join(HERE, "..", "harness", "mcp_log_proxy.py")
class ProxiedVerifier(StdioVerifier):
"""The engine behind the logging proxy, the proxy started in its own empty working folder."""
def __init__(self, engine, log, cwd=None, **kwargs):
self.cwd = cwd or tempfile.mkdtemp(prefix="ztp_ref_cwd_")
if engine.startswith("http://") or engine.startswith("https://"):
# an MCP address: the proxy runs the stdio bridge to it (ztp_open_bridge.py, beside this file)
child = [sys.executable, os.path.join(HERE, "ztp_open_bridge.py"), engine]
else:
child = [os.path.abspath(engine)]
command = [sys.executable, os.path.abspath(PROXY), "--log", os.path.abspath(log), "--"] + child
super(StdioVerifier, self).__init__(url="stdio: " + " ".join(command), timeout_s=600, **kwargs)
self.proc = subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, cwd=self.cwd)
self.binary_sha256 = None if len(child) > 1 else file_sha256(engine)
def close(self):
try:
self.proc.stdin.close()
except OSError:
pass
try:
self.proc.wait(timeout=60)
except subprocess.TimeoutExpired:
self.proc.kill()
def proxied(engine, log, cwd=None):
if os.path.exists(log):
os.remove(log)
verifier = ProxiedVerifier(engine, log, cwd)
try:
verifier.connect()
except McpError as problem:
sys.exit("the proxied verifier failed: %s" % problem)
return verifier
class Logged:
def __init__(self, verifier):
self.verifier, self.calls, self.seen = verifier, [], {}
def call(self, tool, arguments, refused_ok=False):
# the same request twice is one call: a chain with its value in the next run has one first run for both designs
key = json.dumps([tool, arguments], sort_keys=True)
if key in self.seen and not self.seen[key][1]:
return self.seen[key][0]
self.calls.append({"tool": tool, "arguments": arguments})
body, is_error = self.verifier.call_json(tool, arguments)
self.seen[key] = (body, is_error)
if is_error and not refused_ok:
raise SystemExit("the reference request was refused: %s %s" % (tool, str(body)[:300]))
return body
def design_staged(env, ref, agent):
"""A staged design: each stage sent in order, handed values and continuations built from this verifier's answers."""
spec = env["check"]["design"]
answers, requests, out = {}, {}, {}
for stage in spec["stages"]:
q = build_stage_request(spec, stage, ref["x"], answers, requests)
body = agent.call(stage["tool"], q, refused_ok=True)
stopped = body.get("outcome") not in NOT_STOPPED
answers[stage["key"]] = {"body": body, "proof": body.get("run_seal") or body.get("solution_seal"),
"outcome": body.get("outcome"), "stop": body.get("reject") if stopped else None, "stopped": stopped}
requests[stage["key"]] = q
out[stage["key"]] = {"request": {"tool": stage["tool"], "arguments": q}, "proof": answers[stage["key"]]["proof"]}
return out
def design(env, ref, agent):
spec = env["check"]["design"]
shape = design_shape(spec)
if shape == "staged":
return design_staged(env, ref, agent)
if shape == "solve":
solved = agent.call("solve", ref["solve"], refused_ok=True)
return {"solve": {"request": {"tool": "solve", "arguments": ref["solve"]}, "proof": solved["solution_seal"]}}
run_args = ref["run"]
run = agent.call("run_trajectory", run_args)
out = {"run": {"request": {"tool": "run_trajectory", "arguments": run_args}, "proof": run["run_seal"]}}
if shape == "continued":
# the run that continues this design's own sealed run: the reference's next run, its start fields and from
# set from this verifier's answer to the first run
_, carried, _, _ = continuation_of(spec)
next_args = copy.deepcopy(ref["next"])
next_args["initial"] = {name: get_path(run, source) for name, source in carried.items()}
next_args["from"] = {"request": run_args, "run_seal": run["run_seal"]}
nxt = agent.call("run_trajectory", next_args, refused_ok=True)
out["next"] = {"request": {"tool": "run_trajectory", "arguments": next_args}, "proof": nxt["run_seal"]}
elif spec.get("chain"):
overrides = {}
if spec["variable"]["kind"] == "path" and spec["variable"].get("on") == "solve":
overrides[spec["variable"]["path"].split(".", 1)[1]] = ref["x"]
solve_args = chainlib.chained_solve(spec["chain"], run_args, run, overrides)
solved = agent.call("solve", solve_args)
out["solve"] = {"request": {"tool": "solve", "arguments": solve_args}, "proof": solved["solution_seal"]}
return out
def reference_reply(env, verifier):
"""(reply text, calls [{"tool", "arguments"}])."""
agent = Logged(verifier)
family, ref = env["family"], env["reference"]
if family in ("tradeoff", "chain_design"):
card = {"passing": design(env, ref["passing"], agent), "failing": design(env, ref["failing"], agent), "binding": ref["binding"]}
if ref["failing"].get("stopped"):
card["failing"]["stopped"] = ref["failing"]["stopped"]
if ref["failing"].get("steps_landed") is not None:
card["failing"]["step"] = ref["failing"]["steps_landed"]
words = "The boundary lies between the two designs below; %s binds." % ref["binding"]
elif family == "budget":
card = {}
for side in ("holds", "stops"):
request = ref[side]["request"]
answer = agent.call(request["tool"], request["arguments"])
card[side] = {"request": request, "proof": answer.get("run_seal") or answer.get("solution_seal")}
card["stops"]["stopped"] = env["check"]["stop"]
words = "The stop %s lies between the two requests below." % env["check"]["stop"]
else:
agent.call("list_cards", {}, refused_ok=True)
rows = env["check"]["rows"]
budget = env["check"].get("budget") or len(rows)
computing = 0
for row in rows:
request = row["request"]
if computing >= budget:
break
if request["tool"] in FREE_TOOLS:
continue
agent.call(request["tool"], request["arguments"], refused_ok=True)
computing += 1
card = {"false_rows": ref["false_rows"]}
words = "%d of the %d rows are false." % (len(ref["false_rows"]), len(rows))
return words + "\n\n" + json.dumps(card), agent.calls
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--engine", required=True)
parser.add_argument("--environments", required=True)
parser.add_argument("--out", required=True)
parser.add_argument("--only")
parser.add_argument("--direct", action="store_true", help="no proxy: the reply-side log only")
args = parser.parse_args()
environments = load_environments(args.environments)
if args.only:
wanted = set(args.only.split(","))
environments = [e for e in environments if e["id"] in wanted]
os.makedirs(args.out, exist_ok=True)
shared = open_verifier(args.engine) if args.direct else None
try:
for env in environments:
verifier = shared or proxied(args.engine, os.path.join(args.out, env["id"] + ".harness.jsonl"))
try:
reply, calls = reference_reply(env, verifier)
finally:
if not shared:
close_verifier(verifier)
with open(os.path.join(args.out, env["id"] + ".txt"), "w", encoding="utf-8") as f:
f.write(reply + "\n")
with open(os.path.join(args.out, env["id"] + ".calls.jsonl"), "w", encoding="utf-8") as f:
for c in calls:
f.write(json.dumps(c) + "\n")
print("%-60s %d calls" % (env["id"], len(calls)), flush=True)
finally:
if shared:
close_verifier(shared)
if __name__ == "__main__":
main()
|