#!/usr/bin/env python3
"""Owned GNE tool completion with a strict custom Qwen XML decoder.

This is NOT an Ollama-native parser. Only fresh assistant rollout bytes enter
the decoder. The immutable GNE base supplies the same native kernel/lowering;
host-issued, newly bound independent conformance is still required for edits.
Stdlib-only until explicit load; never installs dependencies or starts a server.
"""
import ctypes
import hashlib
import importlib.util
import json
import math
import os
from pathlib import Path
import re
import struct
import sys

VERSION = "omnius.nol.gne-tools.v1"
DECODER = "custom_qwen_xml_decoder_v1"
BASE_SHA = "0db5e4df7fb6553e6714f1b51bec40b1e4654373aa4c58623a6a9eeeb9e7de95"
TEMPLATE_SHA = "c3cf9e34abf4f9e36c2d72165aa9c132d3e2a725b6c2586aaa3a8af9d7a81041"
MODEL_FILE_SHA = "91804f5668d8e5deef47cced0e4ecff9d30da6e965418307d92f3a2822be4248"
SCHEMAS_SHA = "16342f4e8164325504a19d11fd7eebe0e25768677d478a92677259bbf14810b9"
NAMES = {"sandbox_read", "sandbox_write", "verify_sandbox", "task_complete"}
BASE_PATH = Path(__file__).resolve().parent / "nol-gne-worker.py"
if BASE_PATH.is_symlink() or hashlib.sha256(BASE_PATH.read_bytes()).hexdigest() != BASE_SHA:
    raise RuntimeError("Frozen GNE companion identity changed")
spec = importlib.util.spec_from_file_location("_nol_frozen_gne_tools_base", BASE_PATH)
base = importlib.util.module_from_spec(spec)
spec.loader.exec_module(base)
require, fields, integer, number, Rejected = base.require, base.fields, base.integer, base.number, base.Rejected
ORIGINAL_RUNTIME = base.runtime_info
# Only this private module namespace changes. Inherited conformance and evidence
# import must bind the NEW executing worker, never label the old base proof as
# evidence for a different decoder/runtime. Both immutable hashes remain pins.
base.__file__ = __file__
base.WORKER_VERSION = VERSION


def decoder_binding():
    return {"id": DECODER, "templateDigest": TEMPLATE_SHA, "schemasDigest": SCHEMAS_SHA,
            "source": "full-sha256-bound GGUF tokenizer.chat_template Qwen XML function/parameter protocol",
            "thinking": False, "parallelCallLimit": 4, "streaming": False,
            "mixedProseAndCalls": "unsupported", "hostTextToToolConversion": False}


def runtime_info(*args, **kwargs):
    result = ORIGINAL_RUNTIME(*args, **kwargs)
    result.update(schema="omnius.nol.gne-tools-build.v1", workerVersion=VERSION,
                  baseWorkerSha256=BASE_SHA, toolDecoder=decoder_binding())
    return result


base.runtime_info = runtime_info


def tools_inventory(tools):
    require(type(tools) is list and len(tools) == 4, "Exactly the four frozen sandbox schemas are supported", "UNSUPPORTED")
    schemas, names = {}, set()
    for tool in tools:
        fields(tool, ("type", "function"))
        require(tool["type"] == "function", "Only function tools are supported", "UNSUPPORTED")
        function = tool["function"]
        fields(function, ("name", "parameters"), ("description",))
        name = function["name"]
        require(name in NAMES and name not in names, "Unknown or duplicate tool name", "UNSUPPORTED")
        require("description" not in function or type(function["description"]) is str and len(function["description"].encode()) <= 1000, "Tool description exceeds bound")
        names.add(name)
        schemas[name] = function["parameters"]
    require(base.digest_bytes(base.canonical_simple(schemas).encode()) == SCHEMAS_SHA,
            "Sandbox schema inventory differs from frozen native boundary", "IDENTITY")
    return schemas


def validate(value, schema, depth=0):
    require(depth <= 8, "Tool argument nesting exceeds bound", "MODEL_OUTPUT_INVALID")
    kind = schema["type"]
    if kind == "object":
        require(type(value) is dict and len(value) <= 16, "Expected bounded argument object", "MODEL_OUTPUT_INVALID")
        properties = schema["properties"]
        require(set(schema.get("required", [])) <= value.keys() and not (value.keys() - properties.keys()), "Unknown, missing or duplicate argument", "MODEL_OUTPUT_INVALID")
        for key, item in value.items(): validate(item, properties[key], depth + 1)
    elif kind == "string":
        require(type(value) is str and schema.get("minLength", 0) <= len(value) <= schema.get("maxLength", 1024), "String argument violates schema", "MODEL_OUTPUT_INVALID")
        if "pattern" in schema: require(re.search(schema["pattern"], value) is not None, "String pattern mismatch", "MODEL_OUTPUT_INVALID")
    elif kind == "integer":
        require(type(value) is int and schema.get("minimum", -9007199254740991) <= value <= schema.get("maximum", 9007199254740991), "Integer argument violates schema", "MODEL_OUTPUT_INVALID")
    else:
        raise Rejected("UNSUPPORTED", "Frozen sandbox schema uses an unsupported primitive")
    if "enum" in schema: require(value in schema["enum"], "Argument enum mismatch", "MODEL_OUTPUT_INVALID")


def decode_qwen(raw, schemas, finish_reason):
    require(type(raw) is bytes and len(raw) <= 262144, "Fresh assistant output byte bound exceeded", "CAPACITY")
    text = raw.decode("utf-8", "strict")
    require(finish_reason == "stop", "Truncated completion cannot authorize tools", "MODEL_OUTPUT_INVALID")
    require("```" not in text and "<think>" not in text and "</think>" not in text, "Fenced or thinking output cannot authorize tools", "MODEL_OUTPUT_INVALID")
    stripped = raw.strip(b" \t\r\n")
    if not stripped.startswith(b"<tool_call>"):
        require(b"<tool_call" not in raw and b"<function=" not in raw and not stripped.startswith((b"{", b"[")), "Unframed JSON/XML is not a native call", "MODEL_OUTPUT_INVALID")
        return {"content": text, "tool_calls": [], "callSpans": []}
    calls, spans, seen, position = [], [], set(), 0
    while position < len(raw):
        while position < len(raw) and raw[position] in b" \t\r\n": position += 1
        if position == len(raw): break
        start = position
        marker = b"<tool_call>\n<function="
        require(raw.startswith(marker, position), "Mixed prose or malformed tool framing", "MODEL_OUTPUT_INVALID")
        position += len(marker)
        end = raw.find(b">\n", position)
        require(end >= position and end - position <= 64, "Malformed native function name", "MODEL_OUTPUT_INVALID")
        name = raw[position:end].decode("ascii", "strict")
        require(name in schemas, "Unknown native function", "MODEL_OUTPUT_INVALID")
        position, arguments = end + 2, {}
        while not raw.startswith(b"</function>\n</tool_call>", position):
            marker = b"<parameter="
            require(raw.startswith(marker, position), "Malformed or missing function close", "MODEL_OUTPUT_INVALID")
            position += len(marker)
            end = raw.find(b">\n", position)
            require(end >= position and end - position <= 64, "Malformed parameter name", "MODEL_OUTPUT_INVALID")
            key = raw[position:end].decode("ascii", "strict")
            require(key in schemas[name]["properties"] and key not in arguments, "Unknown or duplicate parameter", "MODEL_OUTPUT_INVALID")
            position = end + 2
            end = raw.find(b"\n</parameter>\n", position)
            require(end >= position and end - position <= 65536, "Unterminated or oversized parameter", "MODEL_OUTPUT_INVALID")
            value = raw[position:end].decode("utf-8", "strict")
            require(not any(marker in value for marker in ("<tool_call", "<function=", "<parameter=", "</function>", "</tool_call>")), "Nested protocol control tags are unsupported", "MODEL_OUTPUT_INVALID")
            schema = schemas[name]["properties"][key]
            arguments[key] = value if schema["type"] == "string" else base.parse_json(value)
            position = end + len(b"\n</parameter>\n")
        position += len(b"</function>\n</tool_call>")
        validate(arguments, schemas[name])
        identity = base.canonical_gguf({"name": name, "arguments": arguments})
        require(identity not in seen and len(calls) < 4, "Duplicate native call or batch bound exceeded", "MODEL_OUTPUT_INVALID")
        seen.add(identity)
        call_id = "gne-call-" + base.digest_bytes(raw[start:position])[:16] + "-" + str(start)
        calls.append({"id": call_id, "type": "function", "function": {"name": name, "arguments": arguments}})
        spans.append({"toolCallId": call_id, "startByte": start, "endByte": position})
    return {"content": "", "tool_calls": calls, "callSpans": spans}


def validate_messages(messages, schemas):
    require(type(messages) is list and 0 < len(messages) <= 256, "Bounded chat history required")
    issued, consumed = {}, set()
    for message in messages:
        fields(message, ("role", "content"), ("tool_calls", "tool_call_id", "name"))
        role = message["role"]
        require(role in ("system", "user", "assistant", "tool") and (type(message["content"]) is str or role == "assistant" and message["content"] is None), "Plain native text history required", "UNSUPPORTED")
        require(len((message["content"] or "").encode()) <= 1048576, "Chat content byte bound exceeded", "CAPACITY")
        if role == "tool":
            require(set(message) <= {"role", "content", "tool_call_id", "name"} and message.get("tool_call_id") in issued and message["tool_call_id"] not in consumed, "Tool result has no unique earlier native assistant call", "IDENTITY")
            require("name" not in message or message["name"] == issued[message["tool_call_id"]], "Tool result name differs from its parent", "IDENTITY")
            consumed.add(message["tool_call_id"])
        elif role == "assistant" and "tool_calls" in message:
            require(set(message) <= {"role", "content", "tool_calls"} and type(message["tool_calls"]) is list and 0 < len(message["tool_calls"]) <= 4, "Invalid typed assistant history")
            for call in message["tool_calls"]:
                fields(call, ("id", "type", "function"));fields(call["function"], ("name", "arguments"))
                name, key = call["function"]["name"], call["id"]
                require(call["type"] == "function" and type(key) is str and 0 < len(key) <= 200 and key not in issued and name in schemas, "Forged, duplicate or unsupported history call", "IDENTITY")
                validate(call["function"]["arguments"], schemas[name]);issued[key] = name
        else: require(set(message) == {"role", "content"}, "Role cannot carry native call metadata", "IDENTITY")
    require(set(issued) == consumed, "Every earlier call needs exactly one tool result before the next model request", "IDENTITY")


class Runtime(base.Runtime):
    def __init__(self):
        super().__init__()
        self.poisoned = self.closed = False
        self.tool_limits = None
        self.charged_tokens = self.turns = self.calls = 0
        self.seen_cache_keys = set()
        self._conformance_tools = None

    def ready(self):
        require(not self.poisoned and not self.closed, "Tool worker is closed or poisoned", "RESET")
        super().ready()

    def load(self, payload):
        fields(payload, ("checkpointRoot", "artifactRoot", "workRoot", "gneRoot", "model", "binding", "gpuUuid", "identity", "dependencyLockPath", "limits", "toolLimits"))
        require(not self.poisoned and not self.closed, "Tool worker cannot be reloaded", "RESET")
        model = payload["model"]
        require(model["chatTemplateDigest"] == TEMPLATE_SHA and len(model["files"]) == 1 and model["files"][0]["artifact"]["sha256"] == MODEL_FILE_SHA and model["architecture"] == {"family": "qwen35", "layers": 64, "hiddenSize": 5120}, "Only the exact approved original Qwen GGUF/template is admitted", "UNSUPPORTED")
        limits = payload["toolLimits"]
        fields(limits, ("maxTurns", "maxTotalTokens", "maxToolCalls", "maxOutputBytes"))
        integer(limits["maxTurns"], 1, 16);integer(limits["maxTotalTokens"], 1, 2000000)
        integer(limits["maxToolCalls"], 1, 32);integer(limits["maxOutputBytes"], 1, 262144)
        result = super().load({key: value for key, value in payload.items() if key != "toolLimits"})
        try:
            from gne.engine import render_template, C
            self.render_template, self.native_c = render_template, C
            self.tool_limits = dict(limits)
            result.update(implementation=VERSION, baseWorkerSha256=BASE_SHA, toolDecoder=decoder_binding(),
                          supportedRuntimeOperations=["NEURON_ADD"], canonicalEditsRequireFreshHostIssuedConformance=True,
                          nativeToolAuthority=False, noHiddenSelectorCalls=True)
            return result
        except BaseException:
            self.poisoned = True
            raise Rejected("LOAD_FAILED", "Native tool initialization failed", True)

    def tokenize(self, payload):
        self.ready()
        if self._conformance_tools is not None and set(payload) == {"messages"}:
            tools = self._conformance_tools
        else:
            fields(payload, ("messages", "tools", "toolChoice"))
            require(payload["toolChoice"] == "auto", "Only native auto tool selection is supported", "UNSUPPORTED")
            tools = payload["tools"]
        schemas = tools_inventory(tools)
        validate_messages(payload["messages"], schemas)
        engine = self.session.engine
        require(base.digest_bytes(engine.chat_template.encode()) == TEMPLATE_SHA, "Effective native tool template changed", "IDENTITY")
        text = self.render_template(engine.chat_template, payload["messages"], tools=tools,
                                    enable_thinking=False, add_generation_prompt=True,
                                    bos_token=engine.token_text(self.native_c.llama_vocab_bos(engine.vocab)),
                                    eos_token=engine.token_text(self.native_c.llama_vocab_eos(engine.vocab)))
        ids = engine.tokenize_prompt(text)
        require(0 < len(ids) <= self.limits["maxInputTokens"] and len(text.encode()) <= 1048576, "Native tool prompt exceeds budget", "CAPACITY")
        return {"tokenIds": ids, "promptTokens": len(ids), "renderedPrompt": text,
                "renderedPromptDigest": base.digest_bytes(text.encode()), "chatTemplateDigest": TEMPLATE_SHA,
                "decoder": decoder_binding(), "schemasDigest": SCHEMAS_SHA}

    def reset(self):
        require(not self.poisoned and not self.closed, "Closed or poisoned tool worker cannot reset", "RESET")
        try: return super().reset()
        except BaseException:
            self.poisoned = True
            raise Rejected("RESET", "Native tool reset failed; retire this worker", True)

    def profile(self, payload):
        self.ready()
        mode = payload.get("mode")
        if mode == "tool_render_conformance":
            fields(payload, ("mode", "messages", "tools", "toolChoice"))
            result = self.tokenize({key: value for key, value in payload.items() if key != "mode"})
            return {"schema": "omnius.nol.gne-tool-render-conformance.v1", "binding": self.binding,
                    "workerSha256": base.hash_file(Path(__file__).resolve())["sha256"], "baseWorkerSha256": BASE_SHA,
                    "tokenization": result, "inputTokens": 0, "sampledTokens": 0, "nativeForwards": 0,
                    "authority": "none"}
        if mode == "neuron_add_conformance":
            fields(payload, ("mode", "messages", "tools", "toolChoice", "operations", "maxTokens", "absoluteTolerance", "relativeTolerance"))
            require(payload["toolChoice"] == "auto" and len(payload["operations"]) == 1, "One exact tool-context cell per bounded conformance capture", "CAPACITY")
            tools_inventory(payload["tools"])
            self._conformance_tools = payload["tools"]
            try:
                tokenized = self.tokenize({"messages": payload["messages"]})
                reserved = 3 * len(tokenized["tokenIds"])
                require(self.charged_tokens + reserved <= self.tool_limits["maxTotalTokens"], "Conformance token budget exhausted", "CAPACITY")
                self.charged_tokens += reserved
                return base.Runtime.conformance(self, {key: value for key, value in payload.items() if key not in ("tools", "toolChoice")})
            finally:
                self._conformance_tools = None
                # Local numeric self-reports grant no canonical edit authority.
                # Only a subsequent private-host-issued evidence import can.
                for operation in payload["operations"]: self.validated_cells.pop(self.cell_key(operation), None)
        if mode == "accept_neuron_add_conformance":
            return base.Runtime.accept_conformance(self, payload)
        raise Rejected("UNSUPPORTED", "Unknown explicit tool-worker profile mode")

    def raw_output(self, engine, token_ids, stopped):
        pieces, body, offset = [], [], 0
        for index, token in enumerate(token_ids):
            integer(token, 0, engine.n_vocab - 1)
            size = 256
            while True:
                buffer = ctypes.create_string_buffer(size)
                length = self.native_c.llama_token_to_piece(engine.vocab, token, buffer, size, 0, True)
                if length >= 0: break
                size = -length
                require(0 < size <= 65536, "Native token piece exceeds byte budget", "CAPACITY")
            piece = buffer.raw[:length]
            terminal = stopped and index == len(token_ids) - 1
            require(not terminal or engine.is_eog(token), "Native stop token is not EOG", "IDENTITY")
            pieces.append({"index": index, "tokenId": token, "bytesHex": piece.hex(),
                           "startByte": offset, "endByte": offset if terminal else offset + len(piece), "terminalEog": terminal})
            if not terminal:
                offset += len(piece)
                require(offset <= self.tool_limits["maxOutputBytes"], "Native raw output exceeds storage budget", "CAPACITY")
                body.append(piece)
        raw = b"".join(body)
        visible = token_ids[:-1] if stopped else token_ids
        require(engine.detokenize(visible, special=True) == raw.decode("utf-8", "strict"), "Native token pieces do not reconstruct exact output", "IDENTITY")
        return raw, pieces

    def generate(self, payload):
        self.ready()
        fields(payload, ("messages", "tools", "toolChoice", "recipe", "recipeIdentityJson", "cacheKeyDigest", "seed", "maxTokens", "decoding"))
        schemas = tools_inventory(payload["tools"])
        tokenized = self.tokenize({key: payload[key] for key in ("messages", "tools", "toolChoice")})
        prompt = tokenized["tokenIds"]
        maximum = integer(payload["maxTokens"], 1, self.limits["maxOutputTokens"])
        seed = integer(payload["seed"], 0, 4294967295)
        require(base.SHA.fullmatch(payload["cacheKeyDigest"] or ""), "Cold completion identity required")
        require(payload["cacheKeyDigest"] not in self.seen_cache_keys, "A logical native completion cannot be dispatched twice", "IDENTITY")
        decoding = payload["decoding"]
        fields(decoding, ("temperature", "topP", "topK", "constrainedDecoding"))
        require(number(decoding["temperature"]) == 0 and number(decoding["topP"]) == 1 and integer(decoding["topK"]) == 0 and decoding["constrainedDecoding"] == "none", "V1 tool evaluation is fixed greedy/no-grammar decoding", "UNSUPPORTED")
        require(self.last_reset is not None and not self.created_loras, "Explicit clean reset required before each model turn", "RESET")
        require(len(prompt) + maximum <= self.binding["contextLimit"] and self.turns < self.tool_limits["maxTurns"] and self.charged_tokens + len(prompt) + maximum <= self.tool_limits["maxTotalTokens"], "Native turn/context/total reservation budget exhausted", "CAPACITY")
        recipe = payload["recipe"]
        if recipe is None: require(payload["recipeIdentityJson"] is None, "Baseline cannot carry a recipe identity")
        else:
            base.verify_identity(payload["recipeIdentityJson"], {key: value for key, value in recipe.items() if key != "recipeDigest"}, recipe["recipeDigest"])
            require(all(operation["operation"] == "NEURON_ADD" and operation["units"] == "raw" for operation in recipe["operations"]), "Only freshly validated raw neuron-add cells are supported", "UNSUPPORTED")
        before, engine = self.last_reset, self.session.engine
        context = engine.steer_ctx()
        original_decode, original_prefill = engine._decode, engine.prefill
        observed, counts = {}, {"prefillCalls": 0, "rolloutCalls": 0}
        def decode(ctx, items):
            require(ctx is context and all(item[2] == 0 and 0 <= item[1] < len(prompt) + maximum - 1 and item[1] not in observed for item in items), "Unexpected or repeated native decode position", "CAPACITY")
            require(len({item[1] for item in items}) == len(items), "Duplicate position inside native batch", "CAPACITY")
            for token, position, sequence, logits in items:
                require(position >= len(prompt) or token == prompt[position], "Native prefill token differs from rendered request", "IDENTITY")
            result = original_decode(ctx, items)
            for token, position, sequence, logits in items: observed[position] = token
            return result
        def prefill(ctx, sequences, **kwargs):
            require(counts["prefillCalls"] == 0 and ctx is context and sequences == [prompt], "Hidden selector or second prefill is prohibited", "CAPACITY")
            counts["prefillCalls"] += 1
            return original_prefill(ctx, sequences, **kwargs)
        self.turns += 1
        self.seen_cache_keys.add(payload["cacheKeyDigest"])
        reservation = len(prompt) + maximum
        self.charged_tokens += reservation
        try:
            vectors, lora, operations = self.install(recipe)
            engine.set_lora(context, lora);engine.set_cvec(context, vectors or None)
            engine._decode, engine.prefill = decode, prefill
            prefilled = engine.prefill(context, [prompt])
            counts["rolloutCalls"] += 1
            sampling = self.Sampling(temperature=0, top_p=1, top_k=0, min_p=0, presence_penalty=0, seed=seed, dry_multiplier=0)
            rollout = engine.generate_greedy(context, [prompt], max_tokens=maximum, top_k=min(5, engine.n_vocab), prefilled=prefilled, sampling=sampling)[0]
            ids = rollout.token_ids
            require(type(ids) is list and 0 < len(ids) <= maximum and counts == {"prefillCalls": 1, "rolloutCalls": 1}, "Native rollout count or token budget changed", "IDENTITY")
            expected = prompt + ids[:-1]
            require(sorted(observed) == list(range(len(expected))) and all(observed[index] == token for index, token in enumerate(expected)), "Native decode ledger omits or repeats actual work", "IDENTITY")
            stopped = rollout.finish == "eog"
            raw, pieces = self.raw_output(engine, ids, stopped)
            finish = "stop" if stopped else "length"
            try:
                message = decode_qwen(raw, schemas, finish)
                require(self.calls + len(message["tool_calls"]) <= self.tool_limits["maxToolCalls"], "Total native tool-call budget exceeded", "CAPACITY")
                for call, span in zip(message["tool_calls"], message["callSpans"]):
                    call_id = "gne-call-" + base.digest_bytes((payload["cacheKeyDigest"] + ":" + str(span["startByte"]) + ":" + str(span["endByte"]) + ":").encode() + raw)[:32]
                    call["id"] = span["toolCallId"] = call_id
                    covered = [piece["index"] for piece in pieces if not piece["terminalEog"] and piece["endByte"] > span["startByte"] and piece["startByte"] < span["endByte"]]
                    require(covered, "Native call has no generated token span", "IDENTITY")
                    span.update(startToken=covered[0], endToken=covered[-1] + 1)
                self.calls += len(message["tool_calls"])
                status, failure = "decoded", None
            except (Rejected, UnicodeError, ValueError) as error:
                message = {"content": "", "tool_calls": [], "callSpans": []}
                status, failure = "invalid_model_output", {"code": "MODEL_OUTPUT_INVALID", "message": str(error)[:1000]}
            self.charged_tokens -= maximum - len(ids)
            engine._decode, engine.prefill = original_decode, original_prefill
            after = self.reset()
            return {"schema": "omnius.nol.gne-native-tool-completion.v1", "status": status,
                    "message": {"role": "assistant", "content": message["content"], "tool_calls": message["tool_calls"]},
                    "decoder": {**decoder_binding(), "callSpans": message["callSpans"], "failure": failure},
                    "rawOutputHex": raw.hex(), "rawOutputSha256": base.digest_bytes(raw), "tokenPieces": pieces,
                    "promptTokenIds": prompt, "tokenIds": ids, "renderedPrompt": tokenized["renderedPrompt"],
                    "renderedPromptDigest": tokenized["renderedPromptDigest"], "usage": {"promptTokens": len(prompt), "completionTokens": len(ids)},
                    "finishReason": finish, "execution": {**counts, "decodePositions": sorted(observed), "usageAttested": True, "cumulativeChargedTokens": self.charged_tokens},
                    "native": {"binding": self.binding, "implementation": VERSION, "workerSha256": base.hash_file(Path(__file__).resolve())["sha256"], "baseWorkerSha256": BASE_SHA,
                               "operations": operations, "editedPositions": {item["operationId"]: sorted(observed) for item in operations},
                               "recipeDigest": recipe["recipeDigest"] if recipe else None, "cacheKeyDigest": payload["cacheKeyDigest"],
                               "resetBefore": before, "resetAfter": after, "usesCache": True, "cacheScope": "within_model_request_only", "capabilityAuthority": "none"}}
        except BaseException:
            engine._decode, engine.prefill = original_decode, original_prefill
            try: self.reset()
            except BaseException:
                self.poisoned = True
                raise Rejected("RESET", "Tool generation failed to restore native state", True)
            raise

    def close(self):
        require(not self.poisoned, "Poisoned worker must retire without fallback", "RESET")
        try:
            result = super().close();self.closed = True;return result
        except BaseException:
            self.poisoned = True
            raise Rejected("RESET", "Native tool close failed; retire process", True)


def serve():
    sys.stdout = sys.stderr
    require(0 < base.MAX_FRAME <= 67108864 and all(base.OWNER.values()), "Owned worker scope and frame limit required")
    runtime, sequence = Runtime(), 0
    while True:
        header = base.read_exact(sys.stdin.buffer, 4)
        if header is None: break
        size = struct.unpack(">I", header)[0];require(0 < size <= base.MAX_FRAME, "Frame bound exceeded", "CAPACITY")
        raw = base.read_exact(sys.stdin.buffer, size);require(raw is not None, "Truncated frame")
        request = base.parse_json(raw.decode("utf-8", "strict"))
        fields(request, ("schema", "kind", "sessionId", "jobId", "ownerId", "generation", "id", "action", "payload"))
        require(request["schema"] == base.PROTOCOL and request["kind"] == "request" and all(request[key] == value for key, value in base.OWNER.items()) and request["id"] == sequence + 1, "Owner/generation/sequence mismatch", "IDENTITY")
        sequence += 1
        response = {key: request[key] for key in ("schema", "sessionId", "jobId", "ownerId", "generation", "id", "action")};response["kind"] = "response"
        closing = False
        try:
            action, payload = request["action"], request["payload"]
            if action == "hello":
                fields(payload, ())
                result = {"protocol": base.PROTOCOL, "workerVersion": VERSION, "workerSha256": base.hash_file(Path(__file__).resolve())["sha256"], "baseWorkerSha256": BASE_SHA,
                          "pid": os.getpid(), "loaded": runtime.loaded, "nativeImported": any(name == "gne" or name.startswith("gne.") or name.startswith("llama_cpp") for name in sys.modules), "toolDecoder": decoder_binding(), "capabilityAuthority": "none"}
            elif action in ("inspect", "load", "tokenize", "generate", "profile"):
                result = getattr(runtime, action)(payload)
            elif action == "confirm_placement": result = runtime.confirm(payload)
            elif action in ("reset", "close"):
                fields(payload, ());result = getattr(runtime, action)();closing = action == "close"
            else: raise Rejected("UNSUPPORTED", "Unknown tool worker action")
            response["result"] = result
        except Rejected as error:
            closing = error.fatal or runtime.poisoned or action in ("load", "close")
            response["error"] = {"code": error.code, "message": str(error)[:4096], "fatal": closing}
        except BaseException as error:
            closing = True;response["error"] = {"code": "RUNTIME_FAILURE", "message": type(error).__name__, "fatal": True}
        body = json.dumps(response, ensure_ascii=False, separators=(",", ":"), allow_nan=False).encode()
        require(len(body) <= base.MAX_FRAME, "Response frame bound exceeded", "CAPACITY")
        base.WIRE_OUT.write(struct.pack(">I", len(body)) + body);base.WIRE_OUT.flush()
        if closing: return


if __name__ == "__main__": serve()
