File size: 13,478 Bytes
d6f1470 15055bb 3c4a5ba 6d35eb4 d6f1470 | 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 | #!/usr/bin/env python3
"""Offline test of tests/colab/agentloop_env.py: a scripted ORACLE agent must be accepted on every task kind (thousands of random tasks), and scripted BAD agents must be rejected."""
import json, os, random, re, sys, collections
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "colab")); sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
import agentloop_env as E
from zenyx100m import chat
def C(name, **a): return "<tool_call>" + json.dumps([{"name": name, "arguments": a}], ensure_ascii=False) + "</tool_call>"
def tools_out(tr): return [m["content"] for m in tr if m["role"] == "tool"]
def n_user(tr): return sum(m["role"] == "user" for m in tr)
def oracle(task, bad=None):
k, w, i, user = task.kind, task.world, task.info, task.user
def gen(system, tools, tr):
nt, nu, last = len(tools_out(tr)), n_user(tr), tr[-1]
lt = tools_out(tr)[-1] if nt else ""
if k == "weather":
if last["role"] == "user" and nu == 2:
t = int(re.search(r"(-?\d+)°C", tools_out(tr)[0]).group(1)); return "Yes." if t > i["thr"] else "No."
if nt == 0: return C("get_weather", city=i["city"])
return "It is " + lt.split(": ", 1)[1].replace("°C", " degrees Celsius") + "." if bad != "fab" else "It is 99999 degrees."
if k == "time":
if nt == 0: return C("get_time", timezone=i["tz"])
return "The time there is " + lt.split(": ", 1)[1] + "."
if k == "calc":
if nt == 0: return C("calculator", expression=i["expr"])
return f"That comes to {lt}." if bad != "fab" else "That comes to 123456."
if k == "convert":
if nt == 0: return C("convert_units", value=i["v"], from_unit=i["f"], to_unit=i["t"])
return f"It is {lt.split('= ')[1]}."
if k == "read_note":
topic = next(t for t in E.TOPICS if t in user); fn = next(f for f in w.fs if f.startswith(topic + "."))
return C("read_file", path=fn) if nt == 0 else f"Your note says: {lt}"
if k == "error_recovery":
v = i["variant"]
if v == "wrong_name":
wrong = re.search(r"(\w+\.(?:txt|md))", user).group(1); topic = wrong.split(".")[0]; fn = next(f for f in w.fs if f.startswith(topic + "."))
return [C("read_file", path=wrong), C("list_dir", path="."), C("read_file", path=fn)][nt] if nt < 3 else f"The file says: {lt}"
if v == "transient":
city = next(c for c in E.CITIES if c.lower() in user.lower()); return C("get_weather", city=city) if nt < 2 else "It is " + lt.split(": ")[1].split(",")[0] + "."
fn = re.search(r"(\w+\.(?:txt|md))", user).group(1); return C("read_file", path=fn) if nt == 0 else f"Sorry, I couldn't read {fn}: permission denied."
if k == "empty_result":
oid = re.search(r"\d{5}", user)
if oid: return C("lookup_order", order_id=oid.group(0)) if nt == 0 else "I couldn't find that order, it was not found."
return C("list_dir", path=".") if nt == 0 else "Your folder is empty, so there is no such note."
if k == "ask_then_act":
v = i["variant"]
if v == "control_no_question":
city = next(c for c in E.CITIES if c in user); return C("get_weather", city=city) if nt == 0 else "It is " + lt.split(": ")[1].split("°")[0] + " degrees."
if nu == 1: return {"city": "Which city do you mean?", "recipient": "Who should I send it to?", "time": "What time should I set it for?"}[v]
if v == "city":
city = next(c for c in E.CITIES if c in tr[-1]["content"] or nt) if nt == 0 else None
return C("get_weather", city=next(c for c in E.CITIES if c in tr[-2 if nt == 0 else 0]["content"] or c in " ".join(m["content"] for m in tr if m["role"] == "user"))) if nt == 0 else "It is " + lt.split(": ")[1].split("°")[0] + " degrees."
ru = [m["content"] for m in tr if m["role"] == "user"][1]
if v == "recipient":
to = re.search(r"\S+@\S+", ru).group(0); return C("send_email", to=to, subject="Update", body="As discussed.") if nt == 0 else f"Done, the email was sent to {to}."
tm = re.search(r"\d\d:\d\d", ru).group(0); day = re.search(r"(Monday|Tuesday|Wednesday|Thursday|Friday)", user).group(1)
return C("create_event", title="Event", date=day, time=tm) if nt == 0 else f"Added it for {day} at {tm}."
if k == "confirm_destructive":
fn = re.search(r"(\w+\.(?:txt|md))", user).group(1)
if bad == "nocheck": return C("delete_file", path=fn) if nt == 0 else f"Deleted {fn}."
if nu == 1: return f"Are you sure you want me to delete {fn}?"
if task.info["confirmed"]: return C("delete_file", path=fn) if nt == 0 else f"Done, {fn} is deleted."
return f"Okay, I'll keep {fn}."
if k == "async_job":
if nt == 0: return C("start_job", task=i["what"])
jid = re.search(r"job-\d+", tools_out(tr)[0]).group(0)
if "done." in lt: return f"The job finished: {lt.split('Result: ')[1]}"
return C("check_job", job_id=jid)
if k == "no_tool_needed": return f"Hi, I'm Nini! I can use {', '.join(t['function']['name'] for t in task.tools)} when you need them."
if k == "tool_unavailable": return "Sorry, I can't do that with the tools I have."
if k == "multi_call":
cs = [c for c in E.CITIES if c in user]
if nt == 0: return "<tool_call>" + json.dumps([{"name": "get_weather", "arguments": {"city": c}} for c in cs]) + "</tool_call>"
return " and ".join(f"{c}: {o.split(': ')[1].split('°')[0]} degrees" for c, o in zip(cs, tools_out(tr)))
if k == "dependent_calls":
oid = re.search(r"\d{5}", user).group(0)
if nt == 0: return C("lookup_order", order_id=oid)
if nt == 1: return C("get_customer", customer_id=re.search(r"cust-\d+", lt).group(0))
m = re.search(r"Customer .*?: (\w+), email (\S+), city (\w+)", lt)
return f"The customer is {m.group(1)}, email {m.group(2)}, in {m.group(3)}."
if k == "write_note":
return C("write_file", path=i["fn"], content=i["text"]) if nt == 0 else f"Saved your note to {i['fn']}."
raise AssertionError(k)
return gen
def run(n, seed, bad=None):
rng = random.Random(seed); stat = collections.Counter(); rej = collections.Counter(); sample = {}
for j in range(n):
t = E.make_task(rng); tr, reason = E.rollout(t, oracle(t, bad)); stat[t.kind] += 1
if reason: rej[(t.kind, reason)] += 1
else:
row = E.to_row(t, tr, "oracle", j); sample.setdefault(t.kind, row)
txt, _ = chat.render(row["messages"], json.loads(row["tools"])); assert txt.count("<|im_start|>") >= 2 and len(txt) < 6000
return stat, rej, sample
if __name__ == "__main__":
stat, rej, sample = run(6000, 1)
print("kinds", dict(stat)); print("ORACLE rejections:", dict(rej))
assert not rej, "oracle must be accepted everywhere"
# bad agents must be rejected
for bad, kinds in (("fab", {"weather", "calc"}), ("nocheck", {"confirm_destructive"})):
s2, r2, ok = run(3000, 2, bad)
for k in kinds:
assert s2[k] > 0 and sum(v for (kk, _), v in r2.items() if kk == k) == s2[k], (bad, k, s2[k], dict(r2))
print("bad agent", bad, "rejected on", sorted(kinds), "- all", {k: s2[k] for k in kinds})
# more negatives built by hand
rng = random.Random(5)
def force(kind, tries=400):
for _ in range(tries):
t = E.make_task(rng)
if t.kind == kind: return t
t = force("ask_then_act")
while t.info["variant"] == "control_no_question": t = force("ask_then_act")
tr, r = E.rollout(t, lambda s, tl, h: C({"city": "get_weather", "recipient": "send_email", "time": "create_event"}[t.info["variant"]], **({"city": "Pune"} if t.info["variant"] == "city" else {"to": "a@b.com", "subject": "s", "body": "b"} if t.info["variant"] == "recipient" else {"title": "x", "date": "Monday", "time": "10:00"})) if len(E.World.__dict__) and not any(m["role"] == "tool" for m in h) else "All done.")
assert r, "agent that never asks must be rejected"; print("never-asks rejected:", r)
t = force("async_job"); tr, r = E.rollout(t, lambda s, tl, h: C("start_job", task="x") if not any(m["role"] == "tool" for m in h) else "It finished with 5000 items processed.")
assert r; print("claims result without polling rejected:", r)
t = force("no_tool_needed"); tr, r = E.rollout(t, lambda s, tl, h: C("calculator", expression="1+1") if not any(m["role"] == "tool" for m in h) else "2"); assert r; print("tool for small talk rejected:", r)
t = force("tool_unavailable"); tr, r = E.rollout(t, lambda s, tl, h: "Sure, it is booked <think>x</think>"); assert r; print("unavailable-claim rejected:", r)
t = force("calc"); tr, r = E.rollout(t, lambda s, tl, h: "Text before <tool_call>[{\"name\":\"calculator\",\"arguments\":{\"expression\":\"1+1\"}}]</tool_call>"); assert r; print("text+call rejected:", r)
# the model's NATIVE tool-call syntax must be accepted and stored in our JSON-list format
def native(gen):
def g(system, tools, tr):
out = gen(system, tools, tr)
m = re.fullmatch(r"<tool_call>(\[.*\])</tool_call>", out, re.S)
if not m: return out
return "\n".join(f"<tool_call>{c['name']}" + "".join(f"<arg_key>{k}</arg_key><arg_value>{v}</arg_value>" for k, v in c["arguments"].items()) + "</tool_call>" for c in json.loads(m.group(1)))
return g
rng = random.Random(9); ok = collections.Counter()
for j in range(3000):
t = E.make_task(rng); tr, r = E.rollout(t, native(oracle(t))); assert r is None, (t.kind, r, tr[:4])
for m in tr:
if m["role"] == "assistant" and "<tool_call>" in m["content"]: assert E.TOOL_RX.match(m["content"]) and m["content"].startswith("<tool_call>["), m["content"]; ok["canonical"] += 1
print("native-format agent accepted on 3000 tasks; calls stored canonically:", ok["canonical"])
t = force("weather"); tr, r = E.rollout(t, lambda s, tl, h: "Sure \U0001F600" if any(m["role"] == "tool" for m in h) else "<tool_call>get_weather<arg_key>city</arg_key><arg_value>" + t.info["city"] + "</arg_value></tool_call>"); assert r is None or "tool" in r or "numbers" in r or "misses" in r, r # emojis are allowed now
# a call whose closing tag was swallowed by the server is repaired and stored canonically
t = force("async_job"); state = {"n": 0}
def nocl(s_, tl, h):
if not any(m["role"] == "tool" for m in h): return '<tool_call>[{"name": "start_job", "arguments": {"task": "x"}}]'
last = [m for m in h if m["role"] == "tool"][-1]["content"]
if "done." in last: return "It finished: " + t.world.jobs[next(iter(t.world.jobs))]["result"] + "."
return '<tool_call>[{"name": "check_job", "arguments": {"job_id": "%s"}}]' % next(iter(t.world.jobs))
tr, r = E.rollout(t, nocl); assert r is None, r; assert all(m["content"].endswith("</tool_call>") for m in tr if m["role"] == "assistant" and "<tool_call>" in m["content"]); print("missing closing tag repaired and stored canonically")
assert E.parse_calls('<tool_call>[{"name": "a", "arguments": {}}] and then more text') is None and E.parse_calls("<tool_call>[{broken}]") is None
t = force("confirm_destructive"); fnm = [k for k in t.world.fs][0] if False else sorted(t.world.fs)[0]
tr, r = E.rollout(t, lambda s_, tl, h: f"Sure, I can delete {fnm}. Just confirm and I'll do it." if len([m for m in h if m["role"] == "user"]) == 1 else (C("delete_file", path=fnm) if "yes" in h[-1]["content"] or "confirm" in h[-1]["content"] or "go" in h[-1]["content"] or "sure" in h[-1]["content"] or "yep" in h[-1]["content"] else "Okay, keeping it.") if not any(m["role"] == "tool" for m in h) else "Done, it is deleted.")
assert r in (None, "final answer does not acknowledge the cancellation") or "confirmed" in r or "delet" in r, r; print("confirm without question mark accepted:", r)
# generation-only hints: kind- and state-specific, empty for other kinds, never part of a stored row
u = [{"role": "user", "content": "delete a.txt"}]
assert "NO tool call" in E.gen_hint("confirm_destructive", u) and "confirm" in E.gen_hint("confirm_destructive", u)
u2 = u + [{"role": "assistant", "content": "Delete a.txt?"}, {"role": "user", "content": "yes"}]
assert "answered" in E.gen_hint("confirm_destructive", u2)
assert E.gen_hint("confirm_destructive", u2 + [{"role": "assistant", "content": "x"}, {"role": "tool", "content": "Deleted a.txt."}]) == ""
j = [{"role": "user", "content": "run it"}, {"role": "assistant", "content": "x"}]
assert "start_job" in E.gen_hint("async_job", j[:1])
assert "NOT finished" in E.gen_hint("async_job", j + [{"role": "tool", "content": "Job job-1: running (30% done)."}])
assert "finished" in E.gen_hint("async_job", j + [{"role": "tool", "content": "Job job-1: done. Result: 5 items processed"}])
assert "can't" in E.gen_hint("tool_unavailable", u)
for k in ("weather", "calc", "read_note", "error_recovery", "no_tool_needed"): assert E.gen_hint(k, u) == ""
print("gen_hint ok")
print("ALL AGENTLOOP TESTS PASSED")
|