"""Contatore delle chiamate al motore (banco ALB v2, BRIEF §5): un passante HTTP fra chi chiama (banco per A/T/B, mnemonic-proxy per D/E) e il motore (Strata o motore finto). Ogni POST /v1/chat/completions che arriva al motore passa di qui UNA volta e viene registrato una volta: giri interni del proxy, note di passaggio, retry K, rigioco, compattazioni di B, risposta finale. Nessuna modifica al corpo o alla risposta (passaggio byte per byte; lo stream SSE viene inoltrato riga per riga mentre lo si legge). Per chiamata: kind, max_tokens, reasoning_budget_tokens, enable_thinking, strumenti offerti, messaggi, prompt / generazione / cache (usage), timings del motore, TTFT e durata visti dal contatore, finish_reason, caratteri di content e ragionamento, chiamate a strumenti, stato HTTP, e il controllo a posteriori prompt_tokens + max_tokens + margine <= W (margin_violation). kind: header X-Bench-Kind se presente (chiamate dirette del banco); altrimenti (chiamate del proxy): replay max_tokens == 1 (rigioco della storia) notes un messaggio contiene il marcatore delle note di passaggio round l'ultimo messaggio è un risultato di strumento (giro interno: dopo recall/answerfix) final il resto (richiesta finale inoltrata, eventuale retry K senza strumenti) """ from __future__ import annotations import http.client import json import threading import time import urllib.parse from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer NOTES_MARKS = ("[strata-context: handoff notes request]", "[strata-context: richiesta note di passaggio]") HOP = {"connection", "keep-alive", "transfer-encoding", "te", "trailer", "upgrade", "proxy-connection", "content-length"} def _kind(body: dict, hdr: str | None) -> str: if hdr: return hdr if int(body.get("max_tokens") or body.get("max_completion_tokens") or 0) == 1: return "replay" msgs = body.get("messages") or [] for m in msgs: c = m.get("content") c = c if isinstance(c, str) else json.dumps(c, ensure_ascii=False) if c else "" if any(k in c for k in NOTES_MARKS): return "notes" if msgs and msgs[-1].get("role") == "tool": return "round" return "final" class Meter: def __init__(self, upstream: str, log_path, window: int, margin: int = 64, port: int = 0): u = urllib.parse.urlparse(upstream) self.host, self.uport = u.hostname, u.port or 80 self.window, self.margin = int(window), int(margin) self.logf = open(log_path, "a") self.lock = threading.Lock() self.n = 0 meter = self class H(BaseHTTPRequestHandler): protocol_version = "HTTP/1.1" def log_message(self, *a): pass def _fwd_simple(self, method, data=None): conn = http.client.HTTPConnection(meter.host, meter.uport, timeout=3600) hdrs = {k: v for k, v in self.headers.items() if k.lower() not in HOP and k.lower() != "host"} conn.request(method, self.path, body=data, headers=hdrs) r = conn.getresponse() return conn, r def do_GET(self): conn, r = self._fwd_simple("GET") d = r.read() self.send_response(r.status) for k, v in r.getheaders(): if k.lower() not in HOP: self.send_header(k, v) self.send_header("Content-Length", str(len(d))) self.end_headers() self.wfile.write(d) conn.close() def do_POST(self): n = int(self.headers.get("Content-Length") or 0) data = self.rfile.read(n) if not self.path.startswith("/v1/chat/completions"): conn, r = self._fwd_simple("POST", data) d = r.read() self.send_response(r.status) for k, v in r.getheaders(): if k.lower() not in HOP: self.send_header(k, v) self.send_header("Content-Length", str(len(d))) self.end_headers() self.wfile.write(d) conn.close() return try: body = json.loads(data or b"{}") except ValueError: body = {} ctk = body.get("chat_template_kwargs") or {} rec = {"t_start": time.time(), "kind": _kind(body, self.headers.get("X-Bench-Kind")), "max_tokens": int(body.get("max_tokens") or body.get("max_completion_tokens") or 0), "reasoning_budget_tokens": body.get("reasoning_budget_tokens"), "enable_thinking": ctk.get("enable_thinking"), "stream": bool(body.get("stream")), "n_messages": len(body.get("messages") or []), "tools": [(t.get("function") or {}).get("name") for t in body.get("tools") or []]} t0 = time.time() conn, r = self._fwd_simple("POST", data) rec["http_status"] = r.status ttft, usage, timings, finish = None, None, None, None content, reasoning, calls = 0, 0, {} ctype = r.getheader("Content-Type") or "" if r.status >= 400 or "event-stream" not in ctype: d = r.read() self.send_response(r.status) for k, v in r.getheaders(): if k.lower() not in HOP: self.send_header(k, v) self.send_header("Content-Length", str(len(d))) self.end_headers() self.wfile.write(d) ttft = time.time() - t0 try: j = json.loads(d) if r.status >= 400: rec["error"] = json.dumps(j.get("error") or j)[:500] else: ch = (j.get("choices") or [{}])[0] msg = ch.get("message") or {} usage, timings, finish = j.get("usage"), j.get("timings"), ch.get("finish_reason") content = len(msg.get("content") or "") reasoning = len(msg.get("reasoning_content") or "") for i, c in enumerate(msg.get("tool_calls") or []): calls[i] = (c.get("function") or {}).get("name") except ValueError: rec["error"] = d[:500].decode("utf-8", "replace") else: self.send_response(r.status) for k, v in r.getheaders(): if k.lower() not in HOP: self.send_header(k, v) self.send_header("Connection", "close") self.end_headers() while True: line = r.readline() if not line: break self.wfile.write(line) s = line.strip() if s.startswith(b"data:"): p = s[5:].strip() if p == b"[DONE]": self.wfile.flush() continue try: c = json.loads(p) except ValueError: continue usage = c.get("usage") or usage timings = c.get("timings") or timings for ch in c.get("choices") or []: dl = ch.get("delta") or {} if ttft is None and (dl.get("content") or dl.get("reasoning_content") or dl.get("tool_calls")): ttft = time.time() - t0 content += len(dl.get("content") or "") reasoning += len(dl.get("reasoning_content") or "") for tc in dl.get("tool_calls") or []: nm = (tc.get("function") or {}).get("name") k = tc.get("index", len(calls)) calls[k] = (calls.get(k) or "") + (nm or "") finish = ch.get("finish_reason") or finish elif not s: self.wfile.flush() self.wfile.flush() self.close_connection = True conn.close() u = usage or {} pt = u.get("prompt_tokens") rec.update(wall_s=time.time() - t0, ttft_s=ttft, finish_reason=finish, usage=usage, timings=timings, prompt_tokens=pt, completion_tokens=u.get("completion_tokens"), cached_tokens=((u.get("prompt_tokens_details") or {}).get("cached_tokens") if isinstance(u.get("prompt_tokens_details"), dict) else None), content_chars=content, reasoning_chars=reasoning, tool_calls=[calls[k] for k in sorted(calls)]) if pt is not None: rec["window_slack"] = meter.window - (int(pt) + rec["max_tokens"] + meter.margin) rec["margin_violation"] = rec["window_slack"] < 0 with meter.lock: meter.n += 1 rec["seq"] = meter.n meter.logf.write(json.dumps(rec, ensure_ascii=False) + "\n") meter.logf.flush() self.srv = ThreadingHTTPServer(("127.0.0.1", port), H) self.srv.daemon_threads = True self.port = self.srv.server_address[1] self.url = "http://127.0.0.1:%d" % self.port self.th = threading.Thread(target=self.srv.serve_forever, daemon=True) self.th.start() def close(self): self.srv.shutdown() self.srv.server_close() self.logf.close() def summarize(path) -> dict: """Costi completi da engine_calls.jsonl: totali e per kind (ogni chiamata al motore contata una volta).""" tot = {"n_calls": 0, "prompt_tokens": 0, "completion_tokens": 0, "cached_tokens": 0, "prompt_n": 0, "cache_n": 0, "prompt_ms": 0.0, "predicted_ms": 0.0, "wall_s": 0.0, "max_prompt_tokens": 0, "finish_length": 0, "empty_output": 0, "http_errors": 0, "margin_violations": 0, "min_window_slack": None, "max_tokens_sum": 0, "reasoning_budget_given": 0} by = {} try: lines = open(path).read().splitlines() except OSError: lines = [] for l in lines: c = json.loads(l) for t in (tot, by.setdefault(c["kind"], {k: (0 if not isinstance(v, float) else 0.0) if v is not None else None for k, v in tot.items()})): t["n_calls"] += 1 t["prompt_tokens"] += int(c.get("prompt_tokens") or 0) t["completion_tokens"] += int(c.get("completion_tokens") or 0) t["cached_tokens"] += int(c.get("cached_tokens") or 0) tm = c.get("timings") or {} t["prompt_n"] += int(tm.get("prompt_n") or 0) t["cache_n"] += int(tm.get("cache_n") or 0) t["prompt_ms"] += float(tm.get("prompt_ms") or 0.0) t["predicted_ms"] += float(tm.get("predicted_ms") or 0.0) t["wall_s"] += float(c.get("wall_s") or 0.0) t["max_prompt_tokens"] = max(t["max_prompt_tokens"], int(c.get("prompt_tokens") or 0)) t["finish_length"] += c.get("finish_reason") == "length" t["empty_output"] += (c.get("http_status") == 200 and not c.get("content_chars") and not c.get("tool_calls") and c.get("max_tokens", 0) > 1) t["http_errors"] += int(c.get("http_status") or 0) >= 400 t["margin_violations"] += bool(c.get("margin_violation")) if c.get("window_slack") is not None: t["min_window_slack"] = c["window_slack"] if t["min_window_slack"] is None else \ min(t["min_window_slack"], c["window_slack"]) t["max_tokens_sum"] += int(c.get("max_tokens") or 0) t["reasoning_budget_given"] += c.get("reasoning_budget_tokens") is not None tot["by_kind"] = by return tot