"""AgentLongBench x Flash Next: parti comuni (percorsi, prompt e scorer UFFICIALI, conteggio token, client HTTP). Il prompt e lo scorer sono il codice ufficiale (src/AgentLongBench, commit 57e13e8) importato così com'è: eval.common.question_logic.build_prompt / parse_response (come eval/run.py) eval.evaluate.evaluate (scorer) Interprete: venv-proxy-v0.3.2/bin/python (stdlib + tokenizers + ctxproxy per il template di Flash Next). """ from __future__ import annotations import http.client import json import os import sys import tempfile import time import urllib.parse from pathlib import Path BENCH = Path(__file__).resolve().parent.parent # alb-bench-v2 (copia di lavoro su MVLINNA) A = Path(os.environ.get("ALB", str(BENCH / "alb"))) # dati, scorer ufficiale e proxy 0.3.4 copiati da PC4070TI DATA = A / "data/benchmark" OFFICIAL = A / "src/AgentLongBench" PACK_TOK = os.environ.get("PACK_TOK", str(BENCH / "tok")) # copia di /mnt/gsq-ssd/strata-data/packs/iq3_xxs/tokenizer PROXY_SRC = Path(os.environ.get("PROXY_SRC", str(A / "src/mnemonic-proxy-034"))) # proxy installato 0.3.4 MODEL_NAME = "qwen3.8-flash-next-iq3_xxs" sys.path.insert(0, str(OFFICIAL)) from eval.common.mapping import infer_context_from_path # noqa: E402 (ufficiale) from eval.common.question_logic import build_prompt, parse_response # noqa: E402 (ufficiale) from eval import evaluate as official_evaluate # noqa: E402 (ufficiale) # --------------------------------------------------------------------------------------------------------------- def load_sample(path: Path, qid: str) -> dict: with open(path) as f: for line in f: if f'"id": "{qid}"' in line[:200] or f'"id":"{qid}"' in line[:200]: r = json.loads(line) if r.get("id") == qid: return r with open(path) as f: # ricerca lenta (id non in testa alla riga) for line in f: r = json.loads(line) if r.get("id") == qid: return r raise KeyError(qid) def official_messages(sample: dict, path: Path) -> list[dict]: """Messaggi esattamente come eval/run.py::_process_sample: system ufficiale + storia (senza il system del campione) + domanda come ultimo messaggio user.""" _, knowledge_label, _, history_label = infer_context_from_path(path) return build_prompt(sample["question_type"], sample, history_label, knowledge_label) def official_parse(sample: dict, path: Path, raw: str): _, _, _, history_label = infer_context_from_path(path) return parse_response(sample["question_type"], history_label, raw) def official_score(sample: dict, path: Path, raw: str) -> dict: """Punteggio del singolo campione con eval.evaluate.evaluate ufficiale (file di predizione di una riga, record costruito come in eval/run.py).""" pred, kind = official_parse(sample, path, raw) rec = {"id": sample.get("id"), "sample_id": sample.get("sample_id"), "question_type": sample["question_type"], "pred_answer": pred, "parse_kind": kind, "raw_response": raw} for k in ("round", "i_round", "j_round"): if k in sample: rec[k] = sample[k] with tempfile.NamedTemporaryFile("w", suffix=".jsonl", delete=False, dir=os.environ.get("TMPDIR")) as f: f.write(json.dumps(rec, ensure_ascii=False) + "\n") pp = f.name try: res = official_evaluate.evaluate(Path(path), Path(pp)) finally: os.unlink(pp) return {"pred_answer": pred, "parse_kind": kind, "score": res.get("score"), "metric": res.get("metric"), "official": res} # --------------------------------------------------------------------------------------------------------------- class Counter: """Token esatti del prompt come li conta Strata: template (ctxproxy.render, verificato == prompt_tokens nel pilota bench-reddit) + tokenizer del pack.""" def __init__(self): sys.path.insert(0, str(PROXY_SRC)) from ctxproxy import render from ctxproxy.packtok import build self.render = render self.tk = build(PACK_TOK) def text(self, s: str) -> int: return len(self.tk.encode(s, add_special_tokens=False).ids) def prompt(self, messages, tools=None) -> int: return self.text(self.render.render([{k: v for k, v in m.items() if k != "extra"} for m in messages], tools)) # --------------------------------------------------------------------------------------------------------------- class EngineHTTPError(Exception): def __init__(self, status, text): super().__init__("HTTP %d: %s" % (status, text[:2000])) self.status, self.text = status, text def chat(base_url: str, messages: list, *, max_tokens: int, sampling: dict, tools=None, stream=True, extra_body=None, timeout=3600.0, kind="answer", sink=None, headers=None) -> dict: """Una richiesta OpenAI /v1/chat/completions (stdlib). -> {message, finish_reason, usage, timings, m}. m = metriche registrate (TTFT visibile al client, tempi, usage, timings di Strata).""" body = {"model": MODEL_NAME, "messages": messages, "stream": stream, "max_tokens": int(max_tokens)} if stream: body["stream_options"] = {"include_usage": True} if tools: body["tools"] = tools body.update(sampling or {}) body.update(extra_body or {}) u = urllib.parse.urlparse(base_url) t0 = time.time() conn = http.client.HTTPConnection(u.hostname, u.port or 80, timeout=timeout) t_first = None try: conn.request("POST", "/v1/chat/completions", json.dumps(body, ensure_ascii=False).encode(), {"Content-Type": "application/json", **(headers or {})}) r = conn.getresponse() if r.status >= 400: txt = r.read().decode("utf-8", "replace") m = {"kind": kind, "t_start": t0, "wall_s": time.time() - t0, "http_status": r.status, "error": txt[:2000], "n_messages": len(messages)} if sink: sink(m) raise EngineHTTPError(r.status, txt) if not stream: d = json.loads(r.read()) ch = d["choices"][0] msg, finish, usage, timings = ch["message"], ch.get("finish_reason"), d.get("usage"), d.get("timings") else: content, reasoning, calls, finish, usage, timings = [], [], {}, None, None, None while True: line = r.readline() if not line: break line = line.strip() if not line.startswith(b"data:"): continue data = line[5:].strip() if data == b"[DONE]": break try: c = json.loads(data) except ValueError: continue if c.get("error"): raise EngineHTTPError(599, "stream error: %s" % json.dumps(c["error"])) if c.get("usage"): usage = c["usage"] if c.get("timings"): timings = c["timings"] for ch in c.get("choices") or []: d = ch.get("delta") or {} if t_first is None and (d.get("content") or d.get("reasoning_content") or d.get("tool_calls")): t_first = time.time() content.append(d.get("content") or "") reasoning.append(d.get("reasoning_content") or "") for tc in d.get("tool_calls") or []: cur = calls.setdefault(tc.get("index", len(calls)), {"id": None, "type": "function", "function": {"name": "", "arguments": ""}}) cur["id"] = tc.get("id") or cur["id"] fn = tc.get("function") or {} cur["function"]["name"] += fn.get("name") or "" cur["function"]["arguments"] += fn.get("arguments") or "" if ch.get("finish_reason"): finish = ch["finish_reason"] msg = {"role": "assistant", "content": "".join(content) or None} if "".join(reasoning): msg["reasoning_content"] = "".join(reasoning) if calls: msg["tool_calls"] = [calls[i] for i in sorted(calls)] finally: conn.close() t1 = time.time() m = {"kind": kind, "t_start": t0, "wall_s": t1 - t0, "ttft_client_s": (t_first - t0) if t_first else None, "finish_reason": finish, "usage": usage, "timings": timings, "n_messages": len(messages), "content_chars": len(msg.get("content") or ""), "reasoning_chars": len(msg.get("reasoning_content") or ""), "n_tool_calls": len(msg.get("tool_calls") or []), "max_tokens": int(max_tokens)} if sink: sink(m) return {"message": msg, "finish_reason": finish, "usage": usage, "timings": timings, "m": m} def answer_text(msg: dict) -> str: """Testo valutato: il content (come eval/run.py, che legge solo delta.content).""" return msg.get("content") or "" def transcript_line(m: dict, idx: int | None = None) -> str: """v2 (BRIEF §3): un messaggio della storia come testo per il riassunto di B, SENZA perdere nulla di ciò che ALB chiede: numero del messaggio, ruolo, content, nome e argomenti di ogni tool_call (con il suo id), nome e id della chiamata per i risultati degli strumenti. (answer_text resta il solo content: è il testo che lo scorer valuta.)""" head = "[msg %d | %s" % (idx, m.get("role")) if idx is not None else "[%s" % m.get("role") if m.get("role") == "tool": head += " | %s" % (m.get("name") or "tool") + (" | %s" % m["tool_call_id"] if m.get("tool_call_id") else "") parts = [head + "]"] c = m.get("content") if c: parts.append(c if isinstance(c, str) else json.dumps(c, ensure_ascii=False)) for tc in m.get("tool_calls") or []: fn = tc.get("function") or {} parts.append("%s" % (tc.get("id"), fn.get("name"), fn.get("arguments"))) return " ".join(parts) if len(parts) == 1 else parts[0] + " " + "\n".join(parts[1:])