amos b773033658 Record model requests and payloads as prefix deltas in the native trace
Each model_request/model_payload repeated the full context, so the trace
grew with the square of the request count: batch 6 Qwen runs hit 64 MiB
at ~75 requests and 14 attempts (13 graded PASS) were discarded.
Requests now record only items after the common prefix with the previous
one (schema embedded-rollout.pi/2), and pi_run.expand rebuilds full
payloads before the unchanged broker/feedback checks. Needs a new image
(trace6) and recalibration before use.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-18 10:50:56 +08:00

273 lines
14 KiB
Python

"""One Pi task, one private model proxy, and deterministic resource cleanup."""
import argparse
import hashlib
import ipaddress
import json
from pathlib import Path
import sys
import uuid
from . import core
from .model_proxy import ModelProxy, MODEL, MODELS, MODEL_IDS, QWEN_MODEL
PI_ARGV = ["node", "/opt/embedded-rollout/agent/pi.mjs", "--trace", "/trace/native.jsonl"]
def _jsonl(path):
path = core._path(path)
data = core._read(path.parent, path.name, core.MAX_TRACE_BYTES)
records = [json.loads(line) for line in data.decode("utf-8").splitlines()]
if not records or any(not isinstance(record, dict) for record in records):
raise ValueError("evidence must contain JSON objects")
return data, records
def expand(events):
"""Rebuild full model contexts and wire payloads from pi/2 prefix deltas; pi/1 events are already full."""
previous = {}
for event in events:
kind = event.get("type")
if kind not in ("model_request", "model_payload") or "delta" not in event:
continue
body = event["context" if kind == "model_request" else "payload"]
field, start = event["delta"]["field"], event["delta"]["from"]
prior_field, prior = previous.get(kind, (field, []))
if (field != prior_field or type(start) is not int or not 0 <= start <= len(prior) or
not isinstance(body[field], list)):
raise ValueError("invalid model trace delta")
body[field] = prior[:start] + body[field]
previous[kind] = (field, body[field])
return events
def evidence(attempt, broker_log, model=None, max_tokens=None):
"""Check host-held native output against proxy requests and consumed tool results."""
try:
stdout, events = _jsonl(attempt / "agent.stdout")
expand(events)
trace, _ = _jsonl(attempt / "trace/native.jsonl")
_, broker = _jsonl(broker_log)
if trace != stdout:
raise ValueError("native trace differs from host stdout")
ends = [event for event in events if event.get("type") == "session_end"]
if len(ends) != 1 or events[-1] != ends[0]:
raise ValueError("native session has no unique terminal event")
payloads = [event for event in events if event.get("type") == "model_payload"]
requests = [event for event in events if event.get("type") == "model_request"]
if model is not None:
api = MODELS[model]["api"]
headers = [event for event in events if event.get("type") == "trace_header"]
if (len(headers) != 1 or headers[0].get("model", {}).get("id") != model or
headers[0]["model"].get("api") != api or
any(event.get("model", {}).get("id") != model for event in requests) or
any(event.get("payload", {}).get("model") != model for event in payloads)):
raise ValueError("native model identity does not match the requested model")
if max_tokens is not None and any(event.get("payload", {}).get(MODELS[model]["max_tokens_field"]) != max_tokens
for event in payloads):
raise ValueError("wire output limit differs from the configured model limit")
if not payloads or len(payloads) != len(broker) or len(requests) != len(payloads):
raise ValueError("model request counts disagree")
generations = [event["generation_id"] for event in payloads]
if generations != list(range(len(payloads))) or [event["generation_id"] for event in requests] != generations:
raise ValueError("model generation order disagrees")
for payload, observed in zip(payloads, sorted(broker, key=lambda event: event["sequence"])):
digest = hashlib.sha256(json.dumps(payload["payload"], sort_keys=True,
separators=(",", ":"), ensure_ascii=False, allow_nan=False).encode()).hexdigest()
if observed.get("request_payload_sha256") != digest or observed.get("status") != 200:
raise ValueError("proxy did not confirm the recorded model payload")
if model is not None and MODELS[model]["api"] == "openai-responses" and (
observed.get("responses_terminal") != "response.completed" or
observed.get("responses_terminal_count") != 1 or
observed.get("responses_stream_valid") is not True or
observed.get("responses_stream_finished") is not True or
observed.get("response_model") != model or observed.get("response_status") != "completed"):
raise ValueError("Responses stream did not confirm one completed response")
starts, results = set(), set()
for index, event in enumerate(events):
kind = event.get("type")
if kind == "tool_execution_start":
identity = event["toolCallId"]
if identity in starts:
raise ValueError("duplicate tool start")
starts.add(identity)
elif kind == "tool_execution_end":
identity = event["toolCallId"]
if identity not in starts or identity in results:
raise ValueError("tool result has no unique prior start")
results.add(identity)
consumed = any(message.get("role") == "toolResult" and
message.get("toolCallId") == identity and message.get("toolName") == event.get("toolName") and
message.get("content") == event["result"]["content"] and
message.get("isError") == event.get("isError")
for later in events[index + 1:] if later.get("type") == "model_request"
for message in later["context"]["messages"])
if not consumed:
raise ValueError("tool feedback did not enter a later model request")
closed = bool(results) and starts == results
complete = ends[0].get("complete") is True and ends[0].get("closed") is True and closed
return dict(status="VERIFIED" if complete else "UNVERIFIED", session_end=ends[0],
model_requests=len(payloads), payloads_confirmed=True,
tool_feedback_consumed=closed, trace_sha256=hashlib.sha256(trace).hexdigest(),
training_disposition="NOT_TRAIN_READY")
except Exception as error:
return dict(status="UNVERIFIED", reason=str(error), training_disposition="NOT_TRAIN_READY")
def _channel_failed(broker_log):
try:
_, broker = _jsonl(broker_log)
except ValueError:
return False
return any(event.get("status") != 200 for event in broker)
def _absent(result):
return result.returncode != 0 and any(text in result.stderr.lower()
for text in ("no such network", "not found"))
def _network(name):
result = core._cli(["docker", "network", "inspect", name])
if result.returncode:
raise RuntimeError("could not inspect the dedicated network")
network = json.loads(result.stdout)[0]
if network.get("Driver") != "bridge" or network.get("Name") != name:
raise ValueError("expected the dedicated bridge network")
config = network["IPAM"]["Config"][0]
subnet = ipaddress.ip_network(config["Subnet"])
gateway = ipaddress.ip_address(config["Gateway"])
if subnet.version != 4 or not subnet.is_private or gateway not in subnet or not gateway.is_private:
raise ValueError("expected a private IPv4 Docker bridge")
return network, str(gateway), str(subnet)
def _cleanup_network(name, owner):
try:
before = core._cli(["docker", "network", "inspect", name])
if _absent(before):
return "confirmed"
if before.returncode:
return "unknown"
network = json.loads(before.stdout)[0]
if network.get("Labels", {}).get("embedded-rollout.controller") != owner:
return "unknown"
core._cli(["docker", "network", "rm", name])
return "confirmed" if _absent(core._cli(["docker", "network", "inspect", name])) else "unknown"
except (Exception, KeyboardInterrupt):
return "unknown"
def run(task_path, image, credential_file, output_root, calibration=None, agent_timeout=900, model=MODEL):
if model not in MODEL_IDS:
raise ValueError("unsupported rollout model")
task = core.load_task(task_path)
if type(agent_timeout) is not int or not 1 <= agent_timeout <= 86400:
raise ValueError("agent timeout must be 1..86400 seconds")
output = core._path(output_root)
if output == task["_root"] or task["_root"] in output.parents:
raise ValueError("output must be outside the task directory")
output.mkdir(parents=True, exist_ok=True)
control = output / ("pi-" + uuid.uuid4().hex)
control.mkdir(mode=0o700)
receipt = dict(schema="embedded-rollout.pi-control/1", status="UNVERIFIED",
task_verdict="UNVERIFIED", task_id=task["id"], task_digest=task["_digest"],
model_id=model, model_api=MODELS[model]["api"], model_max_tokens=MODELS[model]["max_tokens"],
model_sampling="service-default",
image_id=None, calibration=None, attempt=None, network=None,
calibration_cleanup="not_created", network_cleanup="not_created", proxy_cleanup="not_created", cleanup="confirmed",
pi_evidence=dict(status="UNVERIFIED"), training_disposition="NOT_TRAIN_READY")
proxy = None
network_name = None
network_create_finished = False
phase = "image"
with core._sigterm():
try:
receipt["image_id"] = core._image(image)
phase = "calibration"
if calibration:
calibration = core._path(calibration)
else:
receipt["calibration_cleanup"] = "unknown"
calibration = core.calibrate(task_path, control, image=receipt["image_id"])
calibrated = json.loads(core._read(calibration, "receipt.json"))
receipt["calibration_cleanup"] = "confirmed" if calibrated.get("cleanup") == "confirmed" else "unknown"
receipt["calibration"] = dict(path=str(calibration))
receipt["calibration"] = core._calibration(task, receipt["image_id"], calibration)
phase = "network"
network_name = "rollout-pi-" + uuid.uuid4().hex
receipt.update(network=network_name, network_cleanup="unknown")
created = core._cli(["docker", "network", "create", "--driver", "bridge", "--internal", "--label",
"embedded-rollout.controller=" + control.name, network_name])
network_create_finished = created.returncode >= 0
if created.returncode:
raise RuntimeError("could not create the dedicated network")
_, gateway, subnet = _network(network_name)
phase = "proxy"
proxy = ModelProxy(credential_file, gateway, subnet, control / "broker.jsonl", model=model)
receipt["proxy_cleanup"] = "unknown"
proxy.__enter__()
phase = "agent"
agent_argv = PI_ARGV + ["--model", model, "--max-tokens", str(MODELS[model]["max_tokens"])]
attempt = core.run(task_path, control, receipt["image_id"], agent_argv,
"pi-0.73.1/" + model, calibration, agent_timeout=agent_timeout,
model_base_url=proxy.base_url, agent_network=network_name)
receipt["attempt"] = str(attempt)
task_receipt = json.loads((attempt / "receipt.json").read_text())
receipt.update(task_verdict=task_receipt["task_verdict"], status=task_receipt["status"],
agent_cleanup=task_receipt["cleanup"], agent_exit=task_receipt.get("agent_exit"),
agent_termination=task_receipt.get("termination"))
except KeyboardInterrupt:
receipt.update(status="UNVERIFIED", termination="interrupted", error_phase=phase)
except Exception as error:
receipt.update(status="INFRA_ERROR", error_type=type(error).__name__, error_phase=phase)
finally:
if proxy is not None:
try:
proxy.__exit__(None, None, None)
receipt["proxy_cleanup"] = "confirmed"
except (Exception, KeyboardInterrupt):
receipt["proxy_cleanup"] = "unknown"
if network_name:
receipt["network_cleanup"] = _cleanup_network(network_name, control.name)
if not network_create_finished:
receipt["network_cleanup"] = "unknown"
if receipt["attempt"]:
receipt["pi_evidence"] = evidence(Path(receipt["attempt"]), control / "broker.jsonl", model,
receipt["model_max_tokens"])
if receipt["status"] in ("PASS", "FAIL") and (receipt["pi_evidence"]["status"] != "VERIFIED" or
receipt.get("agent_exit") != 0 or receipt.get("agent_termination") != "exit"):
# The grade stays in task_verdict; an incomplete session is not a task outcome.
receipt["status"] = "INFRA_ERROR" if _channel_failed(control / "broker.jsonl") else "UNVERIFIED"
if "unknown" in (receipt["calibration_cleanup"], receipt["network_cleanup"], receipt["proxy_cleanup"]) or (
receipt.get("agent_cleanup", "confirmed") != "confirmed"):
receipt.update(cleanup="unknown", status="INFRA_ERROR")
core._finish(control, receipt)
return control
def main(argv=None):
parser = argparse.ArgumentParser(description="One calibrated Pi rollout through a private host proxy")
parser.add_argument("task", type=Path)
parser.add_argument("--image", required=True)
parser.add_argument("--credential-file", type=Path, required=True)
parser.add_argument("--output", type=Path, default=Path("runs"))
parser.add_argument("--calibration", type=Path)
parser.add_argument("--agent-timeout", type=int, default=900)
parser.add_argument("--model", choices=MODEL_IDS, default=MODEL)
args = parser.parse_args(argv)
try:
directory = run(args.task, args.image, args.credential_file, args.output,
args.calibration, args.agent_timeout, args.model)
receipt = json.loads((directory / "receipt.json").read_text())
print(json.dumps(dict(controller=str(directory), status=receipt["status"],
task_verdict=receipt["task_verdict"], cleanup=receipt["cleanup"]), indent=2))
return {"PASS": 0, "FAIL": 1}.get(receipt["status"], 2)
except (ValueError, RuntimeError, OSError):
print("Pi controller input or runtime is unavailable", file=sys.stderr)
return 2
if __name__ == "__main__":
sys.exit(main())