#!/usr/bin/env python3
"""Data-only job-owned vLLM transport with lazy native construction.

Import/hello/inspect do not import frameworks or construct a model. Native work
requires the exact source designation and independent private load/placement
channels. CPU fixtures do not establish native compatibility or capabilities.
"""
import hashlib
import importlib.util
import os
from pathlib import Path
import struct
import sys

sys.dont_write_bytecode = True
PROTOCOL = "omnius.nol.worker.v1"
COMPANION_SHA = "483652ee6df313830a11e3c3cd2a442902724dc854475e4f6459de824e573af8"
ROOT = Path(__file__).resolve().parent
COMPANION = ROOT / "nol-vllm-owned-worker.py"
if COMPANION.is_symlink() or not COMPANION.is_file() or COMPANION.stat().st_size > 1048576 or hashlib.sha256(COMPANION.read_bytes()).hexdigest() != COMPANION_SHA:
    raise RuntimeError("Owned vLLM companion source changed")
spec = importlib.util.spec_from_file_location("_nol_vllm_owned_worker", COMPANION)
owned = importlib.util.module_from_spec(spec)
sys.modules[spec.name] = owned
spec.loader.exec_module(owned)
runtime = owned.runtime_module()


def sources():
    return {"workerSha256": hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), "companionSha256": COMPANION_SHA, "runtimeSha256": owned.RUNTIME_SHA}


def hello(native=None):
    return {"protocol": PROTOCOL, "workerVersion": owned.VERSION, "pid": os.getpid(), **sources(),
            "loaded": native is not None, "torchImported": "torch" in sys.modules, "vllmImported": "vllm" in sys.modules,
            "nnsightImported": "nnsight" in sys.modules, "nativeConstructed": native is not None,
            "startupActivation": "unavailable_pending_model_specific_native_conformance", "capabilityAuthority": "none"}


def exact(stream, size):
    raw = bytearray()
    while len(raw) < size:
        block = stream.read(size - len(raw))
        if not block:
            owned.require(not raw, "Truncated frame")
            return None
        raw.extend(block)
    return bytes(raw)



def _bounded_single_error(error, maximum=2048):
    """Private diagnostic data only: no locals, source lines, repr or imports."""
    name = type(error).__name__[:96]
    try:
        reason = str(error)
    except BaseException:
        reason = "<message unavailable>"
    frames, trace, visited = [], error.__traceback__, 0
    while trace is not None and visited < 256:
        code = trace.tb_frame.f_code
        filename = code.co_filename.replace("\\", "/").rsplit("/", 1)[-1]
        frame = filename[:96] + ":" + str(trace.tb_lineno) + ":" + code.co_name[:64]
        frames.append("".join(char if char.isprintable() else "?" for char in frame))
        frames = frames[-6:]
        trace, visited = trace.tb_next, visited + 1
    suffix = " | source_frames=" + " <- ".join(frames)[-512:] if frames else ""
    budget = maximum - len(name) - 2 - len(suffix)
    marker = " ...<truncated>... "
    if len(reason) > budget:
        head = (budget - len(marker)) // 2
        reason = reason[:head] + marker + reason[-(budget - len(marker) - head):]
    reason = "".join(char if char.isprintable() else " " for char in reason)
    return name + (": " + reason if reason else "") + suffix


def bounded_error_message(error):
    """Preserve explicit primary/cleanup causality without locals or source lines."""
    chain, seen, current = [], set(), error
    while current is not None and id(current) not in seen and len(chain) < 3:
        seen.add(id(current))
        cause = current.__cause__
        relation = "explicit_cause" if cause is not None else "handling_context"
        chain.append((current, relation))
        current = cause if cause is not None else (None if current.__suppress_context__ else current.__context__)
    if len(chain) == 1:
        return _bounded_single_error(error)
    # Read oldest-to-newest: the primary failure remains visible even when
    # strict cleanup raises a second failure. No cause is treated as success.
    chain.reverse()
    labels = ["primary"] + [entry[1] + "_then" for entry in chain[1:]]
    separators = " | caused_by_order | "
    allowance = (2048 - len(separators) * (len(chain) - 1) - sum(len(label) + 2 for label in labels)) // len(chain)
    return separators.join(label + "={" + _bounded_single_error(entry[0], allowance) + "}" for label, entry in zip(labels, chain))[:2048]


def serve():
    # Preserve the framed channel before redirecting both Python and native
    # library stdout to stderr. Private placement descriptors remain 3/4.
    wire = os.fdopen(os.dup(1), "wb", buffering=0)
    os.dup2(2, 1)
    sys.stdout = sys.stderr
    maximum = int(os.environ.get("OMNIUS_NOL_MAX_FRAME_BYTES", "1048576"))
    owned.integer(maximum, 1, 1048576)
    identity = {"sessionId": os.environ.get("OMNIUS_NOL_WORKER_SESSION"), "jobId": os.environ.get("OMNIUS_NOL_JOB_ID"),
                "ownerId": os.environ.get("OMNIUS_NOL_OWNER_ID"), "generation": int(os.environ.get("OMNIUS_NOL_GENERATION", "0"))}
    owned.require(all(type(identity[key]) is str and 1 <= len(identity[key]) <= 1024 and not any(ord(char) < 32 for char in identity[key]) for key in ("sessionId", "jobId", "ownerId")), "Fixed private worker ownership required")
    owned.integer(identity["generation"], 1, 9007199254740991)
    sequence, native = 0, None
    while True:
        head = exact(sys.stdin.buffer, 4)
        if head is None: return
        size = struct.unpack(">I", head)[0]
        owned.integer(size, 1, maximum)
        raw = exact(sys.stdin.buffer, size)
        owned.require(raw is not None, "Truncated request")
        request = owned.parse_json(raw.decode("utf8"))
        owned.fields(request, ("schema", "kind", "sessionId", "jobId", "ownerId", "generation", "id", "action", "payload"))
        owned.require(request["schema"] == PROTOCOL and request["kind"] == "request" and all(request[key] == value for key, value in identity.items()) and type(request["id"]) is int and request["id"] == sequence + 1,
                      "Owned request sequence/scope mismatch", "IDENTITY")
        sequence += 1
        response = {key: request[key] for key in ("schema", "sessionId", "jobId", "ownerId", "generation", "id", "action")}
        response["kind"] = "response"
        close = False
        try:
            action, payload = request["action"], request["payload"]
            if action == "hello":
                owned.fields(payload, ())
                result = hello(native)
            elif action == "inspect":
                owned.fields(payload, (), ("includePinnedSources", "runtimeInventory"))
                owned.require(type(payload.get("includePinnedSources", False)) is bool, "Boolean source-inventory switch required")
                inventory = None
                if "runtimeInventory" in payload:
                    request_inventory = payload["runtimeInventory"]
                    owned.fields(request_inventory, ("dependencyLockPath", "dependencyLockSha256", "maxRuntimeBytes", "maxRuntimeFiles"))
                    inventory = owned.runtime_inventory(request_inventory["dependencyLockPath"], request_inventory["dependencyLockSha256"], request_inventory["maxRuntimeBytes"], request_inventory["maxRuntimeFiles"])
                result = {**hello(), "reviewedSources": owned.source_inventory() if payload.get("includePinnedSources") else None,
                          "runtimeBuildComplete": False, "fullNativeInventoryRequiredBeforeFutureLoad": True,
                          "runtimeInventory": inventory}
            elif action == "load":
                owned.fields(payload, ("plan", "loadNonce", "descriptor"))
                startup = owned.plan(payload["plan"])
                owned.require(type(payload["loadNonce"]) is str and 1 <= len(payload["loadNonce"]) <= 128, "Bounded fresh load nonce required")
                owned.require(startup["source"] == sources(), "Startup source identity mismatch", "IDENTITY")
                if owned.NATIVE_RUNTIME_DESIGNATION is None:
                    raise owned.Rejected("Native startup activation awaits separate model-specific conformance; no framework imported or constructor called", "UNSUPPORTED")
                owned.require(native is None, "Native load replay", "CUSTODY")
                channel = owned.PrivatePlacement({**identity, "loadNonce": payload["loadNonce"]}, startup)
                channel.await_grant("authorize_load")
                controller = owned.Admission(startup); controller.begin_load()
                native = runtime.create_designated_engine(owned, controller, channel, payload["descriptor"])
                result = native["startupObservation"]
            elif action in ("generate", "profile", "tokenize"):
                if native is None: raise owned.Rejected("Native work unavailable before designated private load", "UNSUPPORTED", False)
                if action == "tokenize": result = native["runtime"].tokenize(payload)
                elif action == "generate": result = native["runtime"].generate(payload)
                else:
                    owned.fields(payload, ("generation", "captureSiteId"))
                    owned.require(native["policy"]["purpose"] == "conformance" and payload["captureSiteId"] in native["policy"]["captureSiteIds"], "Unissued capture policy", "CUSTODY")
                    bridge = native["bridge"]; bridge.capture_site = payload["captureSiteId"]
                    output = native["runtime"].generate(payload["generation"])
                    capture = bridge.capture(output["native"]["requestId"], output["native"]["recipeDigest"], output["promptTokenIds"], output["native"]["operations"])
                    path = native["workRoot"] / ("capture-" + output["native"]["requestId"] + ".bin")
                    fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, 0o600)
                    try:
                        block = memoryview(capture)
                        while block:
                            count = os.write(fd, block); owned.require(count > 0, "Capture write failed"); block = block[count:]
                        os.fsync(fd)
                    finally: os.close(fd)
                    bridge.capture_site = None
                    result = {"output": output, "capture": {"path": str(path), "sha256": hashlib.sha256(capture).hexdigest(), "sizeBytes": len(capture), "mediaType": "application/x-omnius-vllm-capture"}}
            elif action == "confirm_placement":
                raise owned.Rejected("Placement grants require private host descriptor channel", "UNSUPPORTED", False)
            elif action == "reset":
                owned.fields(payload, ())
                result = native["runtime"].reset() if native is not None else {"loaded": False, "retainedCache": False, "nativeConstructed": False, "capabilityAuthority": "none"}
            elif action == "close":
                owned.fields(payload, ())
                result, close = {"closed": True, "allocationReleaseRequiresHostVerification": True}, True
            else:
                raise owned.Rejected("Unknown worker action", "UNSUPPORTED", False)
            response["result"] = result
        except (owned.Rejected, runtime.Rejected) as error:
            close = error.fatal or request["action"] == "load"
            response["error"] = {"code": error.code, "message": bounded_error_message(error), "fatal": close}
        except BaseException as error:
            response["error"] = {"code": "RUNTIME_FAILURE", "message": bounded_error_message(error), "fatal": True}
            close = True
        body = owned.canonical(response).encode()
        owned.require(len(body) <= maximum, "Response exceeds frame budget", "CAPACITY")
        wire.write(struct.pack(">I", len(body)) + body); wire.flush()
        if close: return


if __name__ == "__main__":
    try: serve()
    except BaseException as error:
        sys.stderr.write("NOL vLLM worker retired: " + type(error).__name__ + "\n")
        sys.exit(1)
