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>
273 lines
14 KiB
Python
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())
|