hugpy-worker 0.1.0__py3-none-any.whl

hugpy_worker/__init__.py

@@ -0,0 +1,7 @@
+"""hugpy_worker — the per-box hugpy worker over the fitevict front door.
+
+Installs on every box (ae, computron, a-brain, …) next to fitevict. Registers
+with the hugpy_core router, heartbeats, and relays /infer calls to the box's
+front door. Holds no model and makes no placement decision.
+"""
+__version__ = "0.1.0"

hugpy_worker/central_client.py

@@ -0,0 +1,131 @@
+# LIFTED VERBATIM from:
+#   /srv/hugpy/src/hugpy/py/fleet/hugpy_fleet/src/hugpy_fleet/worker/agent.py
+#   lines 607-648 (WorkerRejected, central refusal markers),
+#   678-729 (CentralClient), 7403-7417 (_load_worker_id / _save_worker_id).
+# DROPPED: _db_heartbeat_async (Postgres heartbeat mirror; its call removed from
+#   CentralClient.heartbeat) and CentralClient.evictions_ingest — fitevict's
+#   call_log is the record and the HTTP heartbeat is the only beat.
+"""Central node client (registration + heartbeat)."""
+from __future__ import annotations
+
+import json
+import logging
+import os
+import urllib.error
+import urllib.request
+
+logger = logging.getLogger("hugpy_worker")
+
+
+class WorkerRejected(Exception):
+    """Central refused this worker terminally (401 token / 403 blocked).
+
+    Distinct from a transient error or a 410 (re-register): the operator has
+    revoked/blocked us, so the agent should stop rather than retry.
+    """
+    def __init__(self, code: int, message: str = ""):
+        super().__init__(message or f"rejected with HTTP {code}")
+        self.code = code
+
+
+# CENTRAL'S OWN terminal-refusal markers. A 401/403 is only terminal (stop, don't
+# respawn) when it is CENTRAL saying so — its register/heartbeat routes
+# abort(401/403, description=...) with these exact strings (see
+# hugpy_server/app/routes/worker_routes.py: "Worker is blocked by the operator."
+# at the admission gate, "Worker enrollment token invalid or required." at the
+# enrollment gate). A 401/403 whose body carries NEITHER marker is almost always
+# an INTERMEDIARY between us and central — a reverse-proxy / web auth gate /
+# captive login page (a-brain 2026-09-24: dev.hugpy.ai's web gate returned a 403
+# HTML page while central's own record was 'approved' and central logged nothing;
+# the agent read it as a block and os._exit(0)'d permanently). Those must be
+# logged with the URL + body and RETRIED with backoff, never treated as a block.
+_CENTRAL_BLOCK_MARKER = "Worker is blocked by the operator."
+_CENTRAL_ENROLL_MARKER = "Worker enrollment token invalid or required."
+
+
+def _is_central_terminal_refusal(code: int, body: str) -> bool:
+    """True iff an HTTP ``code``/``body`` is CENTRAL's own terminal worker refusal
+    (block or enrollment reject), as opposed to any other 401/403 from a proxy or
+    web gate sitting in front of central. Body-marker matched, case-insensitively
+    and whitespace-tolerant, so an HTML error page that wraps the description
+    still matches while a generic gate page does not."""
+    if code not in (401, 403):
+        return False
+    hay = " ".join((body or "").split()).lower()
+    if not hay:
+        # Central always sends a description; a truly empty body is NOT central's
+        # refusal (a bare proxy 403). Don't treat it as terminal.
+        return False
+    return (_CENTRAL_BLOCK_MARKER.lower() in hay
+            or _CENTRAL_ENROLL_MARKER.lower() in hay)
+
+
+
+class CentralClient:
+    def __init__(self, central_url: str, token: str | None = None):
+        # Endpoints live under /api on the central Flask app.
+        self.base = central_url.rstrip("/") + "/api/llm/workers"
+        self.token = token
+
+    def _post(self, path: str, payload: dict) -> dict:
+        data = json.dumps(payload).encode("utf-8")
+        headers = {"Content-Type": "application/json"}
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+        req = urllib.request.Request(
+            self.base + path, data=data, headers=headers, method="POST",
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=20) as resp:
+                return json.loads(resp.read().decode("utf-8"))
+        except urllib.error.HTTPError as exc:
+            # A 401/403 is terminal (stop, don't respawn) ONLY when CENTRAL says
+            # so — its route bodies carry a specific marker (see
+            # _is_central_terminal_refusal). Any other 401/403 is an intermediary
+            # (proxy / web gate / login page) between us and central: log it with
+            # the URL + body snippet and re-raise so the caller RETRIES with
+            # backoff. Other codes (e.g. 410 "re-register") propagate unchanged.
+            if exc.code in (401, 403):
+                body = ""
+                try:
+                    raw = exc.read()
+                    body = raw.decode("utf-8", "replace") if raw else ""
+                except Exception:  # noqa: BLE001 — body is best-effort context
+                    body = ""
+                if _is_central_terminal_refusal(exc.code, body):
+                    reason = exc.reason or ""
+                    detail = " ".join(body.split())[:300]
+                    raise WorkerRejected(
+                        exc.code,
+                        (reason + (": " + detail if detail else "")).strip()) from exc
+                logger.warning(
+                    "central call %s returned HTTP %s but the body is NOT central's "
+                    "own worker refusal — treating it as an intermediary (proxy / "
+                    "web gate), NOT a block; will retry. body: %s",
+                    self.base + path, exc.code,
+                    (" ".join(body.split())[:300] or "(empty)"))
+                raise
+            raise
+
+    def register(self, payload: dict) -> dict:
+        return self._post("/register", payload)
+
+    def heartbeat(self, worker_id: str, payload: dict) -> dict:
+        return self._post(f"/{worker_id}/heartbeat", payload)
+
+
+def _load_worker_id(path: str) -> str | None:
+    try:
+        with open(path, "r", encoding="utf-8") as fh:
+            return (json.load(fh) or {}).get("worker_id")
+    except (OSError, ValueError):
+        return None
+
+
+def _save_worker_id(path: str, worker_id: str) -> None:
+    try:
+        os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
+        with open(path, "w", encoding="utf-8") as fh:
+            json.dump({"worker_id": worker_id}, fh)
+    except OSError:
+        logger.warning("could not persist worker id to %s", path)

hugpy_worker/worker.py

@@ -0,0 +1,600 @@
+# LIFTED from:
+#   /srv/hugpy/src/hugpy/py/fleet/hugpy_fleet/src/hugpy_fleet/worker/agent.py
+#   — the central<->worker CONTRACT only: WorkerState (6619, trimmed to the
+#   fields the contract uses), _ram_total_bytes (522), _sse (3187),
+#   _terminal_exit (15609), build_app routes /health /infer /infer/stream
+#   /infer/cancel (4606-4925), _heartbeat_loop (16047), _register (16309),
+#   _build_parser (contract flags) and main.
+# SWAPPED: everything below the routes (execute_chat_stream / execute_prompt,
+#   _ensure_present*, gen_gate, _prepare_load_contract, spill, job_store,
+#   aggregate) -> one HTTP call to the fitevict front door
+#   (POST {front_door}/v1/chat/completions). fitevict owns evict-to-fit, load,
+#   serve and call_log; this process holds no model and decides no placement.
+# DROPPED from the beat/register: telemetry produced by the dropped machinery
+#   (slots, allocations, pid_registry, calibration, aggregate, studio, comfy,
+#   storage, doctrine, self-update). Central's request models default them.
+"""hugpy worker harness: central sees an ordinary worker, fitevict serves."""
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import os
+import socket
+import sys
+import threading
+import time
+import urllib.error
+import urllib.request
+import uuid
+
+from flask import Flask, Response, jsonify, request, stream_with_context
+
+from fitevict.lifted.hardware import detect_gpus, free_ram_bytes
+
+from . import __version__
+from .central_client import (CentralClient, WorkerRejected, _load_worker_id,
+                             _save_worker_id)
+
+logger = logging.getLogger("hugpy_worker")
+
+ENGINE = {"installed": True, "backend": "fitevict", "supports_gpu_offload": True}
+
+
+class WorkerState:
+    def __init__(self, name: str, url: str | None, worker_id: str | None,
+                 central_url: str | None = None, port: int | None = None,
+                 front_door: str = "http://127.0.0.1:8080"):
+        self.name = name
+        self.url = url            # None unless operator set --advertise/WORKER_URL
+        self.worker_id = worker_id
+        self.central_url = central_url
+        self.port = port
+        self.front_door = front_door.rstrip("/")
+        # Models central says we should serve (adopted from register/heartbeat).
+        self.assigned_models: list[str] = []
+        # In-flight request ids, so /infer/cancel can answer honestly.
+        self.inflight: set[str] = set()
+        # Last host constraints pushed to the wrapper (None = never pushed).
+        self.limits_sent: "dict | None" = None
+
+
+# ── fitevict front door (the swap) ──────────────────────────────────────────
+def _fd_models(state: WorkerState) -> "list[dict] | None":
+    """GET /v1/models from the front door: [{id, resident, ...discovery}], or
+    None when it could not be read (NOT an empty inventory)."""
+    try:
+        with urllib.request.urlopen(state.front_door + "/v1/models", timeout=10) as r:
+            return (json.loads(r.read().decode("utf-8")) or {}).get("data") or []
+    except Exception:  # noqa: BLE001
+        return None
+
+
+def loaded_model_keys(state: WorkerState) -> list[str]:
+    return sorted(m["id"] for m in (_fd_models(state) or []) if m.get("resident"))
+
+
+def _models_local(state: WorkerState) -> list[str]:
+    return sorted(m["id"] for m in (_fd_models(state) or []))
+
+
+# Idle-vs-serving window (legacy agent.py:1834 _SERVING_WINDOW_S).
+_SERVING_WINDOW_S = 180.0
+
+
+def _fd_residents(state: WorkerState) -> list[dict]:
+    """GET /residents from the front door: its running llama-server children."""
+    try:
+        with urllib.request.urlopen(state.front_door + "/residents", timeout=10) as r:
+            return (json.loads(r.read().decode("utf-8")) or {}).get("residents") or []
+    except Exception:  # noqa: BLE001
+        return []
+
+
+def _allocations(residents: list[dict]) -> list[dict]:
+    """One kind="slot" row per front-door child, in the legacy allocation row
+    shape (agent.py _allocations, slot rows ~2495-2540): measured VRAM per pid
+    (device_source "measured"), else the declared placement ("inferred")."""
+    now = time.time()
+    rows = []
+    for c in residents:
+        if not c.get("alive"):
+            continue
+        vram = c.get("vram_bytes")
+        if vram is not None:
+            device, source = ("cuda" if vram > 0 else "cpu"), "measured"
+        else:
+            ngl = c.get("n_gpu_layers")
+            device = None if ngl is None else ("cpu" if ngl == 0 else "cuda")
+            source = "inferred" if device else None
+        last_used = c.get("last_used") or 0.0
+        row = {
+            "kind": "slot", "model_key": c["key"],
+            "slot_id": c.get("port"), "healthy": c.get("healthy"),
+            "busy": c.get("busy"), "endpoint": c.get("endpoint"),
+            "rss_bytes": c.get("ram_bytes"),
+            "n_gpu_layers": c.get("n_gpu_layers"), "ctx": c.get("ctx"),
+            "vram_bytes": vram, "device": device,
+            "last_used": last_used,
+            "serving": bool(c.get("busy")) or (last_used > 0 and now - last_used <= _SERVING_WINDOW_S),
+            "materialized": bool(c.get("healthy")),
+        }
+        if c.get("n_cpu_moe") is not None:
+            row["n_cpu_moe"] = c["n_cpu_moe"]
+        if source is not None:
+            row["device_source"] = source
+        if c.get("loading"):
+            row["loading"] = True
+            row["materialized"] = False
+        rows.append(row)
+    return rows
+
+
+def _models_discovered(models: list[dict]) -> dict:
+    """{model_key: discovery detail} — every model the box's fitevict found on
+    disk, with its directory, elected GGUF and all weight files (quant, bytes)."""
+    return {m["id"]: {k: v for k, v in m.items() if k not in ("id", "object", "owned_by")}
+            for m in models}
+
+
+def _fd_chat(state: WorkerState, payload: dict, request_id: str) -> "tuple[int, dict]":
+    """Forward one central ChatRequest to the front door. Returns (status, body)."""
+    messages = payload.get("messages")
+    if not messages and payload.get("prompt"):
+        messages = [{"role": "user", "content": payload["prompt"]}]
+    body = {"model": payload.get("model_key"), "messages": messages or [],
+            "max_tokens": payload.get("max_new_tokens") or payload.get("max_tokens"),
+            "task": payload.get("task"),
+            "metadata": {"central_request_id": request_id, "worker": state.name}}
+    if isinstance(payload.get("knobs"), dict):
+        body["knobs"] = payload["knobs"]      # central's pair knobs -> the wrapper's load contract
+    for k in ("temperature", "top_p", "top_k", "stop", "seed"):
+        if payload.get(k) is not None:
+            body[k] = payload[k]
+    body = {k: v for k, v in body.items() if v is not None}
+    req = urllib.request.Request(
+        state.front_door + "/v1/chat/completions",
+        data=json.dumps(body).encode("utf-8"),
+        headers={"Content-Type": "application/json"}, method="POST")
+    try:
+        with urllib.request.urlopen(req, timeout=900) as r:
+            return r.status, json.loads(r.read().decode("utf-8") or "{}")
+    except urllib.error.HTTPError as exc:
+        try:
+            return exc.code, json.loads(exc.read().decode("utf-8") or "{}")
+        except Exception:  # noqa: BLE001
+            return exc.code, {"error": {"message": str(exc)}}
+
+
+def _reply_parts(body: dict) -> "tuple[str, str, dict, dict]":
+    """(text, finish_reason, usage, timings) out of an OpenAI chat payload."""
+    ch = ((body.get("choices") or [{}])[0]) if isinstance(body, dict) else {}
+    text = ((ch.get("message") or {}).get("content")) or ""
+    return (text, ch.get("finish_reason") or "stop",
+            body.get("usage") or {}, body.get("timings") or {})
+
+
+def _error_text(body: dict) -> str:
+    err = body.get("error") if isinstance(body, dict) else None
+    if isinstance(err, dict):
+        return str(err.get("message") or err)
+    return str(err or "front door error")
+
+
+# ── lifted helpers ──────────────────────────────────────────────────────────
+def _ram_total_bytes() -> int | None:
+    """RAW physical RAM (MemTotal) in bytes — the pool-budget denominator.
+
+    Unlike _free_ram_bytes (reserve-adjusted + RAM_MAX-capped so central plans
+    against budgetable RAM), this is the box's total installed memory, so the
+    console can render used-vs-total. Best-effort, mirroring
+    _platform/hardware.free_ram_bytes: psutil first, then /proc/meminfo, else
+    None (never fabricated)."""
+    try:
+        import psutil
+        return int(psutil.virtual_memory().total)
+    except Exception:
+        pass
+    if sys.platform.startswith("linux"):
+        try:
+            with open("/proc/meminfo", "r", encoding="utf-8") as fh:
+                for line in fh:
+                    if line.startswith("MemTotal:"):
+                        return int(line.split()[1]) * 1024
+        except Exception:
+            pass
+    return None
+
+
+def _sse(payload: dict) -> bytes:
+    # werkzeug's WSGI server asserts the app yields bytes, not str — so encode
+    # here. (gunicorn is more lenient, but the worker runs the dev server.)
+    return f"data: {json.dumps(payload, ensure_ascii=False)}\n\n".encode("utf-8")
+
+
+def _terminal_exit(exc: "WorkerRejected") -> None:
+    """Stop the agent for good after central refused it (401/403).
+
+    Called from the daemon heartbeat thread too, so it must kill the whole
+    process (the main thread is blocked in the inference server) — hence
+    os._exit. Exit code 0 so a ``Restart=on-failure`` unit does NOT respawn a
+    deliberately-evicted worker (transient crashes still exit non-zero/killed and
+    are restarted as before).
+    """
+    if getattr(exc, "code", None) == 403:
+        logger.error("central BLOCKED this worker (403): %s. Stopping — have the "
+                     "operator Admit it in the console to rejoin.", exc)
+    else:
+        logger.error("central refused enrollment (401): %s. Stopping — re-enroll "
+                     "with a valid WORKER_ENROLL_TOKEN.", exc)
+    os._exit(0)
+
+
+def _sync_assignment(state: WorkerState, worker: dict | None) -> None:
+    models = (worker or {}).get("models")
+    if isinstance(models, list):
+        state.assigned_models = [str(m) for m in models]
+    _apply_limits(state, (worker or {}).get("fitevict_limits"))
+    _self_update_if_needed(state, (worker or {}).get("required_packages"))
+
+
+# ── self-update (shape lifted from legacy agent.py _self_update_if_needed):
+# central names the package versions to run (the latest on PyPI); a box behind
+# them pip-installs exactly those from PyPI, then re-execs. Never destructive:
+# it waits until nothing is in flight or loading, and restarts the front door
+# (which drops its resident models) only when hugpy-wrapper itself changed.
+_UPDATE_RETRY_BACKOFF = 600.0
+UPDATE_STATE_FILE = os.path.expanduser(os.environ.get("HUGPY_WORKER_UPDATE_STATE",
+                                                      "~/.hugpy_worker/update.json"))
+WRAPPER_PKG = "hugpy-wrapper"
+
+
+def _editable_install() -> bool:
+    """A dev box runs the source tree (pip -e): it never self-updates."""
+    try:
+        from importlib.metadata import distribution
+        raw = distribution("hugpy_worker").read_text("direct_url.json") or "{}"
+        return bool((json.loads(raw).get("dir_info") or {}).get("editable"))
+    except Exception:  # noqa: BLE001
+        return False
+
+
+def _installed(pkg: str) -> "str | None":
+    try:
+        from importlib.metadata import version
+        return version(pkg)
+    except Exception:  # noqa: BLE001
+        return None
+
+
+def _load_update_state() -> dict:
+    try:
+        with open(UPDATE_STATE_FILE, "r", encoding="utf-8") as fh:
+            return json.load(fh) or {}
+    except (OSError, ValueError):
+        return {}
+
+
+def _save_update_state(d: dict) -> None:
+    try:
+        os.makedirs(os.path.dirname(UPDATE_STATE_FILE), exist_ok=True)
+        with open(UPDATE_STATE_FILE, "w", encoding="utf-8") as fh:
+            json.dump(d, fh)
+    except OSError:
+        logger.warning("could not write %s", UPDATE_STATE_FILE)
+
+
+def _box_idle(state: WorkerState) -> bool:
+    """Nothing in flight here and nothing busy or loading in the front door."""
+    if state.inflight:
+        return False
+    try:
+        with urllib.request.urlopen(state.front_door + "/residents", timeout=5) as r:
+            res = (json.loads(r.read().decode("utf-8")) or {}).get("residents") or []
+    except Exception:  # noqa: BLE001 — front door down: nothing of its to lose
+        return True
+    return not any(x.get("busy") or x.get("loading") for x in res)
+
+
+def _self_update_if_needed(state: WorkerState, required: "dict | None") -> None:
+    if not isinstance(required, dict) or not required or _editable_install():
+        return  # central isn't naming versions, or this is a dev (source) install
+    want = {p: v for p, v in required.items() if v and _installed(p) != v}
+    if not want:
+        return
+    st = _load_update_state()
+    if st.get("target") == want and (time.time() - st.get("at", 0)) < _UPDATE_RETRY_BACKOFF:
+        return  # already tried this exact target recently; back off
+    if not _box_idle(state):
+        return  # retried on the next beat, once the box is idle
+    import subprocess
+    logger.info("self-update from PyPI: %s", ", ".join(
+        f"{p} {_installed(p) or '(none)'} -> {v}" for p, v in want.items()))
+    rc = 1
+    try:
+        # the wrapper's pre-rename dist owns the same files: remove it first
+        if _installed("fitevict") is not None:
+            subprocess.call([sys.executable, "-m", "pip", "uninstall", "-y", "-q", "fitevict"])
+        rc = subprocess.call([sys.executable, "-m", "pip", "install", "-q",
+                              *[f"{p}=={v}" for p, v in want.items()]])
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("self-update install failed: %s", exc)
+    if rc != 0:
+        _save_update_state({"target": want, "at": time.time(), "rc": rc})
+        logger.warning("self-update failed (rc=%s); staying on the installed versions", rc)
+        return
+    _save_update_state({"installed": want, "at": time.time(), "rc": 0})
+    if WRAPPER_PKG in want:
+        logger.info("self-update: %s changed; restarting the front door", WRAPPER_PKG)
+        try:
+            subprocess.call(["systemctl", "--user", "restart", "fitevict-frontdoor.service"],
+                            timeout=60)
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("front door restart failed: %s", exc)
+    logger.info("self-update installed %s; re-exec", want)
+    os.execv(sys.executable, [sys.executable, "-m", "hugpy_worker.worker", *sys.argv[1:]])
+
+
+def _apply_limits(state: WorkerState, lim) -> None:
+    """Hand central's host constraints (cap + protected set) to the wrapper,
+    only when they changed. Constraints, not knobs: the wrapper holds them."""
+    if not isinstance(lim, dict):
+        return
+    want = {"gpu_limit": lim.get("gpu_limit"), "ram_limit": lim.get("ram_limit"),
+            "protected": sorted(lim.get("protected") or [])}
+    if want == state.limits_sent:
+        return
+    req = urllib.request.Request(state.front_door + "/limits",
+                                 data=json.dumps(want).encode("utf-8"),
+                                 headers={"Content-Type": "application/json"}, method="POST")
+    try:
+        with urllib.request.urlopen(req, timeout=10):
+            state.limits_sent = want
+            logger.info("wrapper limits set: %s", want)
+    except Exception as exc:  # noqa: BLE001 — retried on the next beat
+        logger.warning("could not set wrapper limits: %s", exc)
+
+
+# ---------------------------------------------------------------------------
+# HTTP server
+# ---------------------------------------------------------------------------
+def build_app(state: WorkerState) -> Flask:
+    app = Flask("hugpy_worker")
+
+    @app.route("/health", methods=["GET"])
+    def health():
+        return jsonify(
+            {
+                "ok": True,
+                "worker_id": state.worker_id,
+                "name": state.name,
+                "gpus": detect_gpus(),
+                "engine": ENGINE,
+                "front_door": state.front_door,
+                "assigned_models": state.assigned_models,
+                "loaded_models": loaded_model_keys(state),
+            }
+        )
+
+    @app.route("/infer", methods=["POST"])
+    def infer():
+        payload = request.get_json(silent=True) or {}
+        req_id = str(payload.pop("request_id", "") or uuid.uuid4().hex)
+        payload.pop("spill", None)
+        if not payload.get("model_key"):
+            return jsonify({
+                "ok": False, "error": "model_key is required",
+                "worker": {"id": state.worker_id, "name": state.name},
+            }), 400
+        state.inflight.add(req_id)
+        try:
+            status, body = _fd_chat(state, payload, req_id)
+        finally:
+            state.inflight.discard(req_id)
+        if status != 200:
+            return jsonify({
+                "ok": False, "error": _error_text(body),
+                "worker": {"id": state.worker_id, "name": state.name},
+            }), status
+        text, finish, usage, timings = _reply_parts(body)
+        return jsonify({"ok": True, "text": text, "finish_reason": finish,
+                        "usage": usage, "timings": timings,
+                        "request_id": req_id})
+
+    @app.route("/infer/stream", methods=["POST"])
+    def infer_stream():
+        payload = request.get_json(silent=True) or {}
+        payload.pop("spill", None)
+        # Caller-supplied id for cancellation; else generate one. Echo it back
+        # as the first SSE event so the client can cancel this exact request.
+        req_id = str(payload.pop("request_id", "") or uuid.uuid4().hex)
+        if not payload.get("model_key"):
+            return jsonify({
+                "ok": False, "error": "model_key is required",
+                "worker": {"id": state.worker_id, "name": state.name},
+            }), 400
+
+        def _generate():
+            state.inflight.add(req_id)
+            try:
+                yield _sse({"type": "request", "request_id": req_id})
+                # The front door answers whole (non-streaming): the reply rides
+                # as one token event, then done with the engine's usage/timings.
+                status, body = _fd_chat(state, payload, req_id)
+                if status != 200:
+                    yield _sse({"type": "error", "message": _error_text(body),
+                                "code": str(status)})
+                    return
+                text, finish, usage, timings = _reply_parts(body)
+                if text:
+                    yield _sse({"type": "token", "text": text})
+                done = {"type": "done", "finish_reason": finish}
+                if usage:
+                    done["usage"] = usage
+                if timings:
+                    done["timings"] = timings
+                yield _sse(done)
+            finally:
+                state.inflight.discard(req_id)
+
+        return Response(
+            stream_with_context(_generate()),
+            mimetype="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "X-Accel-Buffering": "no",
+                "Connection": "keep-alive",
+            },
+            direct_passthrough=True,
+        )
+
+    @app.route("/infer/cancel/<request_id>", methods=["POST"])
+    def infer_cancel(request_id):
+        # Wire contract: 404 for unknown/finished requests. An in-flight request
+        # cannot be stopped yet — the front door has no cancel — so say so.
+        if request_id not in state.inflight:
+            return jsonify({"cancelled": False, "reason": "unknown or finished request"}), 404
+        return jsonify({"cancelled": False, "request_id": request_id,
+                        "reason": "fitevict front door has no cancel yet"}), 409
+
+    return app
+
+
+# ---------------------------------------------------------------------------
+# Registration + heartbeat
+# ---------------------------------------------------------------------------
+def _beat_fields(state: WorkerState) -> dict:
+    return {
+        "gpus": detect_gpus(),
+        "url": state.url,     # None -> central uses the source IP
+        "port": state.port,
+        "pkg_version": __version__,
+        "free_ram": free_ram_bytes(),
+        "ram_total": _ram_total_bytes(),
+        "engine": ENGINE,
+        "pool": os.environ.get("WORKER_POOL", ""),
+    }
+
+
+def _fd_storage(state: WorkerState) -> dict | None:
+    """GET /storage from the front door: the model drive survey."""
+    try:
+        with urllib.request.urlopen(state.front_door + "/storage", timeout=20) as r:
+            return json.loads(r.read().decode("utf-8")) or None
+    except Exception:  # noqa: BLE001
+        return None
+
+
+def _model_fields(state: WorkerState) -> dict:
+    """What this box holds: discovered models (with hugpy.json + weights),
+    which are loaded, and the running children as allocation rows."""
+    models = _fd_models(state)
+    if models is None:
+        # Inventory unreadable this beat (front door down/restarting): report
+        # NO inventory rather than an empty one — an empty object is
+        # authoritative ("the scan found nothing") and would erase this box's
+        # models upstream (instructions/hugpy/model_discovery, rule 2).
+        return {"allocations": _allocations(_fd_residents(state)),
+                "storage": _fd_storage(state)}
+    return {
+        "loaded_models": sorted(m["id"] for m in models if m.get("resident")),
+        "models_local": sorted(m["id"] for m in models),
+        "models_discovered": _models_discovered(models),
+        "allocations": _allocations(_fd_residents(state)),
+        "storage": _fd_storage(state),
+    }
+
+
+def _register(client: CentralClient, state: WorkerState, args) -> None:
+    models = [m.strip() for m in (args.models or "").split(",") if m.strip()]
+    payload = {
+        "name": state.name,
+        "models": models or None,
+        "worker_id": state.worker_id,
+        **_beat_fields(state),
+        # Sent on register too, so a router restart (410 -> re-register) never
+        # leaves the box listed with no models until the next beat.
+        **_model_fields(state),
+    }
+    try:
+        worker = client.register(payload)
+    except WorkerRejected as exc:
+        _terminal_exit(exc)   # does not return — blocked/revoked, don't retry
+    state.worker_id = worker.get("id", state.worker_id)
+    if state.worker_id:
+        _save_worker_id(args.id_file, state.worker_id)
+    _sync_assignment(state, worker)
+    logger.info("registered as worker id=%s serving models=%s", state.worker_id, worker.get("models"))
+
+
+def _heartbeat_loop(client: CentralClient, state: WorkerState, args) -> None:
+    while True:
+        time.sleep(args.heartbeat)
+        try:
+            worker = client.heartbeat(
+                state.worker_id,
+                {**_beat_fields(state), **_model_fields(state)},
+            )
+            # Adopt any assignment change made in the UI.
+            _sync_assignment(state, worker)
+        except WorkerRejected as exc:
+            _terminal_exit(exc)   # does not return
+        except urllib.error.HTTPError as exc:
+            if exc.code == 410:
+                # Central forgot us (restart / cleared registry) — re-register.
+                logger.warning("central returned 410; re-registering")
+                _register(client, state, args)
+            else:
+                logger.warning("heartbeat HTTP %s", exc.code)
+        except Exception as exc:
+            logger.warning("heartbeat failed: %s", exc)
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="hugpy_worker")
+    p.add_argument("--central", default=os.environ.get("HUGPY_BASE_URL")
+                   or os.environ.get("WORKER_CENTRAL_URL"),
+                   help="Central base URL. Omitted -> serve locally, never register.")
+    p.add_argument("--token", default=os.environ.get("WORKER_ENROLL_TOKEN"),
+                   help="Enrollment token issued by the console (hpw_...). Sent as a "
+                        "Bearer credential on register/heartbeat.")
+    p.add_argument("--name", default=os.environ.get("WORKER_NAME", socket.gethostname()))
+    p.add_argument("--host", default=os.environ.get("WORKER_HOST", "0.0.0.0"),
+                   help="Bind address for the worker's inference server")
+    p.add_argument("--port", type=int, default=int(os.environ.get("WORKER_PORT", "9100")))
+    p.add_argument("--advertise", default=os.environ.get("WORKER_URL"),
+                   help="URL the central node should call back on "
+                        "(defaults to http://<host>:<port>)")
+    p.add_argument("--models", default=os.environ.get("WORKER_MODELS", ""),
+                   help="Comma-separated model_keys to self-assign on registration")
+    p.add_argument("--heartbeat", type=float, default=float(os.environ.get("WORKER_HEARTBEAT", "15")))
+    p.add_argument("--id-file", default=os.environ.get(
+        "HUGPY_WORKER_ID_FILE", os.path.expanduser("~/.hugpy_worker/worker_id.json")))
+    p.add_argument("--front-door", default=os.environ.get(
+        "HUGPY_WORKER_FRONT_DOOR", "http://127.0.0.1:8080"),
+                   help="fitevict front door base URL")
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s: %(message)s")
+    args = _build_parser().parse_args(argv)
+    state = WorkerState(name=args.name, url=args.advertise,
+                        worker_id=_load_worker_id(args.id_file),
+                        central_url=args.central, port=args.port,
+                        front_door=args.front_door)
+    if args.central:
+        client = CentralClient(args.central, token=args.token)
+        _register(client, state, args)
+        threading.Thread(target=_heartbeat_loop, args=(client, state, args),
+                         name="hugpy-worker-heartbeat", daemon=True).start()
+    else:
+        logger.info("no --central: serving locally only, not registered")
+    logger.info("hugpy_worker %s on %s:%s -> front door %s",
+                state.name, args.host, args.port, state.front_door)
+    build_app(state).run(host=args.host, port=args.port, threaded=True)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

hugpy_worker-0.1.0.dist-info/METADATA

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: hugpy-worker
+Version: 0.1.0
+Summary: Per-box hugpy worker over the fitevict front door: register, heartbeat, /infer, /infer/stream, cancel, health — lifted from hugpy_fleet.worker; all loading and serving delegated to fitevict.
+Author-email: putkoff <support@hugpy.ai>
+License: Proprietary
+Project-URL: Homepage, https://hugpy.ai
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: hugpy-wrapper
+Requires-Dist: flask>=2
+
+# hugpy-worker
+
+    pip install hugpy-worker   # pulls hugpy-wrapper (the front door)
+
+Per-box hugpy worker over the fitevict front door. Central sees an ordinary hugpy
+worker (register, heartbeat, `/infer`, `/infer/stream`, `/infer/cancel`, `/health`);
+every inference is forwarded to fitevict's `/v1/chat/completions`, which owns
+evict-to-fit, load, serve and call_log. The contract is lifted from
+`hugpy_fleet.worker.agent`; nothing below it is.
+
+    hugpy-worker --central http://127.0.0.1:7020 --name ae-worker --port 9200 \
+        --advertise http://192.168.1.100:9200 --front-door http://127.0.0.1:8080
+
+Without `--central` it serves locally and never registers.

hugpy_worker-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+hugpy_worker/__init__.py,sha256=VMQXUKOO2uu63VdnE_QCBYhDXUpJGRsj66ksjhgjHIU,319
+hugpy_worker/central_client.py,sha256=Hkw07v2h5dgim7Gz0GDUXC2BmnT1FPEp4FdnLEiebWM,6027
+hugpy_worker/worker.py,sha256=mPRSRpadclp4C1yYS5Nj5ZA1IifyYy3N6UgKXBUMM1U,26682
+hugpy_worker-0.1.0.dist-info/METADATA,sha256=SAWVzbEUxRuewGNTCeCAFYf1tbNKf8-99sa1O8l-uJU,1458
+hugpy_worker-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+hugpy_worker-0.1.0.dist-info/entry_points.txt,sha256=mwSMQpIIxbHQvpbT0UBqQOlMa-g6wxOdrr6iYNoTWFc,58
+hugpy_worker-0.1.0.dist-info/top_level.txt,sha256=prqGr888Rup_0WQiNXltc-D5wIn31-3k-gPORCsA5ug,13
+hugpy_worker-0.1.0.dist-info/RECORD,,

hugpy_worker-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

hugpy_worker-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+hugpy-worker = hugpy_worker.worker:main

hugpy_worker-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+hugpy_worker