#!/usr/bin/env python3
"""Agent-loop data generator (Kaggle 2xT4 kernel, one local 4B GGUF model per GPU through llama.cpp).
The MODEL plays the assistant, tests/colab/agentloop_env.py plays the tools and the user.  Every tool call is executed by the simulated world, every rollout is judged against the world state,
only rollouts that really succeed are accepted.  Rejected rollouts are SAVED with their reason (never deleted).  Output repo (append-only commits every few minutes):
    data/<task>/<session>_<seq>.jsonl      accepted rows  {"messages","tools","domain","provider","seed","task_info"}
    rejects/<task>/<session>_<seq>.jsonl   {"reject": reason, "row": {...}}
    status/<kernel>_<session>.json         counters
  python tests/colab/agentloop_run.py --kernel alspark --model_repo XHToken/Spark-X2.6-4B-GGUF --model_file Spark-X2.6-4B-Q8_0.gguf --session_hours 11.2
  python tests/colab/agentloop_run.py --selftest            (no model, no network: an oracle agent plays the assistant; exercises the loop, the buffers and the file layout)"""
import argparse, collections, glob, hashlib, json, os, random, subprocess, sys, threading, time, urllib.request
HERE = os.path.dirname(os.path.abspath(__file__)); sys.path.insert(0, HERE); sys.path.insert(0, os.path.dirname(os.path.dirname(HERE)))
import agentloop_env as E
from zenyx100m import chat as CH
ap = argparse.ArgumentParser()
ap.add_argument("--kernel", default="alspark"); ap.add_argument("--model_repo", default=""); ap.add_argument("--model_file", default=""); ap.add_argument("--repo", default="Arko007/zenyx-agentic-loops")
ap.add_argument("--session_hours", type=float, default=11.2); ap.add_argument("--np", type=int, default=4); ap.add_argument("--gpus", default="0,1"); ap.add_argument("--upload_sec", type=int, default=300)
ap.add_argument("--first_upload_sec", type=int, default=150); ap.add_argument("--selftest", action="store_true"); ap.add_argument("--selftest_seconds", type=int, default=20)
ap.add_argument("--workdir", default="/kaggle/working/gen4b"); ap.add_argument("--max_per_prompt", type=int, default=4); ap.add_argument("--temp", type=float, default=0.7)
A = ap.parse_args()
W = A.workdir; OUT = f"{W}/agentloop_out"; LLAMA_BIN = f"{W}/llama.cpp/build/bin"; os.makedirs(OUT, exist_ok=True)
T_START = time.time(); DEADLINE = T_START + (A.selftest_seconds if A.selftest else A.session_hours * 3600 - 300); SESSION = f"s{int(T_START)}"
PROVIDER = f"llama.cpp:{os.path.basename(A.model_file)}" if A.model_file else "selftest:oracle"
lock = threading.Lock(); buf_lock = threading.Lock(); stop_all = threading.Event(); stats = collections.Counter(); per_kind = collections.defaultdict(collections.Counter); fails = collections.Counter()
offsets = {}; seq = [0]; seen = set(); per_prompt = collections.Counter()
def log(*a):
    with lock: print(f"[agentloop {time.time() - T_START:7.0f}s]", *a, flush=True)
HF_TOKEN = None
if not A.selftest:
    from zenyx100m.secrets import HF_TOKEN
    from huggingface_hub import HfApi, hf_hub_download, CommitOperationAdd
    api = HfApi(token=HF_TOKEN)
def write_local(kind, d, obj):
    p = f"{OUT}/{kind}/{d}.jsonl"; os.makedirs(os.path.dirname(p), exist_ok=True)
    with buf_lock, open(p, "a", encoding="utf-8") as f: f.write(json.dumps(obj, ensure_ascii=False) + "\n")
def upload_cycle(final=False):
    ops, newoffs = [], {}
    with buf_lock:
        for p in glob.glob(f"{OUT}/*/*.jsonl"):
            kind, d = p.split("/")[-2], os.path.basename(p)[:-6]; off = offsets.get(p, 0)
            with open(p, "rb") as f: f.seek(off); data = f.read()
            cut = data.rfind(b"\n") + 1
            if cut <= 0: continue
            seq[0] += 1; ops.append(("%s/%s/%s_%04d.jsonl" % (kind, d, SESSION, seq[0]), data[:cut])); newoffs[p] = off + cut
        st = {"kernel": A.kernel, "session": SESSION, "provider": PROVIDER, "elapsed_s": round(time.time() - T_START), "stats": dict(stats), "per_task": {k: dict(v) for k, v in per_kind.items()}, "reject_reasons": dict(fails.most_common(25))}
        ops.append((f"status/{A.kernel}_{SESSION}.json", json.dumps(st, indent=1).encode()))
    if len(ops) <= 1 and not final: return
    if A.selftest: log("selftest: would upload", [o[0] for o in ops][:6], "..."); offsets.update(newoffs); return
    for attempt in range(6):
        try: api.create_commit(A.repo, [CommitOperationAdd(path_in_repo=a, path_or_fileobj=b) for a, b in ops], repo_type="dataset", commit_message=f"{A.kernel} {SESSION}: +{len(ops) - 1} files"); break
        except Exception as e: log("upload failed (will retry):", str(e)[:160]); time.sleep(30 * (attempt + 1))
    else: return
    with buf_lock: offsets.update(newoffs)
    log(f"uploaded {len(ops) - 1} files")
def uploader():
    stop_all.wait(A.first_upload_sec); upload_cycle()
    while not stop_all.is_set():
        for _ in range(A.upload_sec):
            if stop_all.wait(1): break
        upload_cycle()
# ------------------------------------------------------------------------------------------------------------- llama.cpp servers
servers = []
def healthy(port):
    try: return b"ok" in urllib.request.urlopen(f"http://127.0.0.1:{port}/health", timeout=5).read()
    except Exception: return False
def start_server(gpu, port):
    env = dict(os.environ, CUDA_VISIBLE_DEVICES=str(gpu), LD_LIBRARY_PATH=LLAMA_BIN + ":" + os.environ.get("LD_LIBRARY_PATH", ""))
    cmd = [f"{LLAMA_BIN}/llama-server", "-m", MODEL, "-ngl", "99", "-c", str(A.np * 8192), "-np", str(A.np), "--port", str(port), "--jinja"]
    f = open(f"{W}/server_{port}.log", "ab"); return {"gpu": gpu, "port": port, "p": subprocess.Popen(cmd, env=env, stdout=f, stderr=f)}
def wait_ready(s, t=900):
    t0 = time.time()
    while time.time() - t0 < t:
        if s["p"].poll() is not None: return False
        if healthy(s["port"]): return True
        time.sleep(3)
    return False
if not A.selftest:
    MODEL = hf_hub_download(A.model_repo, A.model_file, local_dir=W + "/models", token=None)
    for k, g in enumerate(A.gpus.split(",")): servers.append(start_server(int(g), 8080 + k))
    oks = [wait_ready(sv) for sv in servers]; log("servers ready:", oks)
    if not all(oks): raise SystemExit("servers failed to start")
    def watchdog():
        while not stop_all.wait(60):
            for s in servers:
                if s["p"].poll() is not None or not healthy(s["port"]):
                    log(f"server {s['port']} down - restarting")
                    try: s["p"].kill()
                    except Exception: pass
                    s.update(start_server(s["gpu"], s["port"])); wait_ready(s)
    threading.Thread(target=watchdog, daemon=True).start()
# ------------------------------------------------------------------------------------------------------------- one rollout
POLICY = ("\n\nWorking rules (follow them silently, never mention them): (1) Use a tool only when it is needed; when you call a tool, your whole reply is just the tool call. "
          "(2) If a required detail is missing (which city, which recipient, what time...), ask the user ONE short question and wait for the answer; never guess it. But if the user already gave everything, do not ask. "
          "(3) Before deleting or overwriting anything, ask the user to confirm and wait. "
          "(4) If a tool returns an error, fix the problem when you sensibly can (for example list the folder to find the right file name) or retry once when the error is temporary; if it still fails, say so honestly and do not invent results. "
          "(5) If a tool finds nothing, say that nothing was found; never invent data. (6) If a job is still running, check its status again until it is done, and only then give the result. "
          "(7) If none of your tools can do what is asked, say you can't do that with the tools you have. (8) Answer in 1-3 short, friendly sentences (an occasional emoji is fine, no long markdown), and report tool values exactly as returned.")
def to_openai(system, tools, tr, kind=None):
    """the assistant sees EXACTLY the training prompt: system text + '# Tools' block (chat.system_with_tools); tool results become user turns '<tool_response>..</tool_response>' (merged when consecutive)"""
    msgs = [{"role": "system", "content": (CH.system_with_tools(system, tools) or "") + POLICY + E.gen_hint(kind, tr)}]
    for m in tr:
        if m["role"] == "tool":
            piece = f"<tool_response>{m['content']}</tool_response>"
            if msgs[-1].get("_tool"): msgs[-1]["content"] += "\n" + piece
            else: msgs.append({"role": "user", "content": piece, "_tool": True})
        else: msgs.append({"role": m["role"], "content": m["content"]})
    return [{k: v for k, v in m.items() if k != "_tool"} for m in msgs]
def chat_call(port, messages):
    body = {"messages": messages, "temperature": A.temp, "top_p": 0.95, "max_tokens": 400, "chat_template_kwargs": {"enable_thinking": False}}
    r = json.loads(urllib.request.urlopen(urllib.request.Request(f"http://127.0.0.1:{port}/v1/chat/completions", json.dumps(body).encode(), {"Content-Type": "application/json"}), timeout=600).read())
    return r["choices"][0]["message"]["content"] or ""
def key_of(task, tr): return hashlib.sha1(json.dumps([task.system, tr], ensure_ascii=False).encode()).hexdigest()
def worker(wid, port):
    n = 0
    while not stop_all.is_set() and time.time() < DEADLINE:
        n += 1; seed = f"{SESSION}-{wid}-{n}"; rng = random.Random(seed); task = E.make_task(rng)
        if A.selftest:
            sys.path.insert(0, os.path.join(os.path.dirname(HERE), ".")); import test_agentloop_env as TA
            gen = TA.oracle(task)
        else:
            gen = lambda system, tools, tr, port=port, kind=task.kind: chat_call(port, to_openai(system, tools, tr, kind))
        try: tr, reason = E.rollout(task, gen)
        except Exception as e:
            with lock: stats["call errors"] += 1
            log("call error:", repr(e)[:140]); time.sleep(5); continue
        row = E.to_row(task, tr, PROVIDER, seed); kind = task.kind
        if reason is None:
            k = key_of(task, tr); pk = (kind, task.user)
            with lock:
                dup = k in seen or per_prompt[pk] >= A.max_per_prompt
                if not dup: seen.add(k); per_prompt[pk] += 1
            if dup: reason = "duplicate or too many rows for the same prompt"
        with lock:
            stats["attempts"] += 1; per_kind[kind]["attempts"] += 1
            if reason: stats["rejected"] += 1; per_kind[kind]["rejected"] += 1; fails[f"{kind}: {reason[:70]}"] += 1
            else: stats["accepted"] += 1; per_kind[kind]["accepted"] += 1
        if reason: write_local("rejects", kind, {"reject": reason, "row": row})
        else: write_local("data", kind, row)
        if stats["attempts"] == 400 and stats["accepted"] < 12 and not A.selftest:
            log("ABORT: acceptance under 3% after 400 rollouts - see rejects/ for the reasons"); stop_all.set()
threads = [threading.Thread(target=worker, args=(k, (servers[k % len(servers)]["port"] if servers else 0))) for k in range(A.np * max(1, len(servers)))]
threading.Thread(target=uploader, daemon=True).start()
for t in threads: t.start()
last = time.time()
while any(t.is_alive() for t in threads):
    time.sleep(5)
    if time.time() - last > 120: last = time.time(); log(f"{dict(stats)} | rejects {dict(fails.most_common(4))}")
log("workers finished - final flush"); stop_all.set(); time.sleep(2); upload_cycle(final=True)
for s in servers:
    try: s["p"].kill()
    except Exception: pass
try:
    import shutil; shutil.make_archive("/kaggle/working/agentloop_rows_backup" if os.path.isdir("/kaggle/working") else OUT + "_backup", "gztar", OUT)
except Exception as e: log("backup archive failed:", str(e)[:100])
log(f"DONE: {dict(stats)} | per task { {k: dict(v) for k, v in per_kind.items()} }")