hugpy-engine 0.2.4__tar.gz → 0.2.5__tar.gz

{hugpy_engine-0.2.4/src/hugpy_engine.egg-info → hugpy_engine-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hugpy-engine
-Version: 0.2.4
+Version: 0.2.5
 Summary: Hugpy engine: model discovery and classification, allocation and eviction, native llama.cpp and GGUF runners, and the prompt-to-reply inference path with task and placement seams
 Author-email: putkoff <support@hugpy.ai>
 License-Expression: LicenseRef-Proprietary

{hugpy_engine-0.2.4 → hugpy_engine-0.2.5}/src/hugpy_engine/catalog_bridge.py

@@ -52,7 +52,14 @@ class EngineCatalogSource:
     def canonical_key(self, model_key: str) -> Optional[str]:
         from hugpy_engine.resolvers.assure_model_key import assure_model_key
 
-        return assure_model_key(model_key)
+        # IDENTITY resolution only (operator rule 2026-09-29): this is the
+        # storage/provision seam a WORKER uses to re-resolve a key central
+        # already resolved (ensure_model_registered -> _assure_local_key). The
+        # shorthand fuzzy tier must never answer here — on ae it turned
+        # ``Qwen3.8-9B-GGUF`` into the resident ``Qwen3.8-9B-Distill-GGUF``
+        # (same file, different model) and served it (S3/F7). None means
+        # "learn the row from central", never "use the nearest sibling".
+        return assure_model_key(model_key, fuzzy=False)
 
     def resolve_dir(self, model_key: str) -> Optional[str]:
         from hugpy_engine.config.main import get_model_path

{hugpy_engine-0.2.4 → hugpy_engine-0.2.5}/src/hugpy_engine/config/main.py

@@ -50,6 +50,14 @@ def _resolve_model_key(model_key, registry, prefer=None):
     def _bare(k):  # name without the "owner~" qualifier
         return k.split("~", 1)[1] if "~" in k else k
     candidates = sorted(k for k in registry if _bare(k) == model_key)
+    if not candidates:
+        # FORMAT EQUIVALENCE (operator rule 2026-09-29): ``X`` and ``X-GGUF``
+        # are one key, so either spelling resolves to the row on record under
+        # the other. Nothing else is folded — ``X-Distill-GGUF`` is a different
+        # model and never answers for ``X-GGUF`` (S3/F7). Lazy import keeps the
+        # config module's import graph unchanged.
+        from hugpy_engine.fit.types import key_equivalent
+        candidates = sorted(k for k in registry if key_equivalent(_bare(k), model_key))
     if not candidates:
         return None
     if len(candidates) == 1:

{hugpy_engine-0.2.4 → hugpy_engine-0.2.5}/src/hugpy_engine/dispatch/activity.py

@@ -95,6 +95,13 @@ def snapshot() -> list:
             "kind": d["kind"],
             "prompt": d.get("prompt") or "",
             "state": state,
+            # WHERE a processing call is (2026-09-29): "prefill" while the
+            # engine is still reading the prompt (n_past/n_prompt ride on
+            # progress/input_tokens), "" once tokens flow. Without this the
+            # queue read "answering, 0 tokens" for a 105 s legitimate prefill.
+            "stage": d.get("stage") or "",
+            "progress": d.get("progress"),
+            "input_tokens": d.get("input_tokens"),
             "elapsed": d["elapsed"],
             "wait": d["wait"],
             "tokens": d["tokens"],

{hugpy_engine-0.2.4 → hugpy_engine-0.2.5}/src/hugpy_engine/dispatch/dispatch.py

@@ -697,7 +697,25 @@ async def stream_runner(runner, req, cancel_event=None):
                         timings=getattr(result, "timings", None))
     else:
         yield ErrorEvent(request_id=req.request_id,
-                         message=getattr(result, "error", None) or "run failed")
+                         message=getattr(result, "error", None) or "run failed",
+                         load_failure=(getattr(result, "load_failure", None)
+                                       if isinstance(getattr(result, "load_failure", None), dict)
+                                       else None))
+
+
+def _rewrap_error_event(event, rid):
+    """The ONE re-wrap of an inner ErrorEvent under the outer request id
+    (S5, 2026-09-29). It used to rebuild the event from ``message`` alone, so
+    the worker's structured ``load_failure`` (class + fit_failure + refusal —
+    F3) and ``code`` were dropped HERE, on central, between the relay and the
+    /v1 envelope: the client saw ``type: api_error`` with no ``fit_failure``
+    although the worker had logged kind=vram_fit. Carry both."""
+    return ErrorEvent(request_id=rid,
+                      message=getattr(event, "message", None) or "run failed",
+                      load_failure=(getattr(event, "load_failure", None)
+                                    if isinstance(getattr(event, "load_failure", None), dict)
+                                    else None),
+                      code=(str(getattr(event, "code")) if getattr(event, "code", None) else None))
 
 
 async def execute_prompt_stream(*args, cancel_event=None, **kwargs):
@@ -948,8 +966,7 @@ async def execute_chat_stream(*args, cancel_event=None, **kwargs):
                                         output_chunks=1, finish_reason="stop",
                                         usage=usage_totals, timings=timings_last)
                     else:
-                        yield ErrorEvent(request_id=rid,
-                                         message=getattr(event, "message", None) or "run failed")
+                        yield _rewrap_error_event(event, rid)
                     errored = True
                     break
                 else:

hugpy_engine-0.2.5/src/hugpy_engine/fit/__init__.py

@@ -0,0 +1,28 @@
+"""``hugpy_engine.fit`` — the pure, deterministic evict-to-fit core.
+
+Standalone: imports only ``hugpy_engine`` siblings (``eviction``, ``spill``)
+and the standard library — no torch, no nvml, no fleet. See ``plan.py``.
+"""
+from __future__ import annotations
+
+from hugpy_engine.fit.flex import (  # noqa: F401
+    FlexPlan, PartialPlan, band_bounds, band_ceiling, band_floor,
+    ctx_band_bounds, flex_priority_key, kv_at_ctx_pct, leniency_floor_pct,
+    plan_explicit_offload, plan_flex, plan_partial_offload,
+)
+from hugpy_engine.fit.plan import evict_order, need_split, plan_fit  # noqa: F401
+from hugpy_engine.fit.types import (  # noqa: F401
+    FAILURE_KINDS, DeviceVram, Eviction, FitFailure, FitPlan, FitPolicy,
+    FitRequest, MoeSplit, Resident, ResourceSnapshot, VramSnapshot,
+    canonical_key, key_equivalent,
+)
+
+__all__ = [
+    "plan_fit", "evict_order", "need_split",
+    "ResourceSnapshot", "VramSnapshot", "DeviceVram", "FitPolicy", "Resident",
+    "FitRequest", "Eviction", "MoeSplit", "FitFailure", "FAILURE_KINDS", "FitPlan",
+    "canonical_key", "key_equivalent",
+    "FlexPlan", "PartialPlan", "band_bounds", "band_ceiling", "band_floor",
+    "ctx_band_bounds", "flex_priority_key", "kv_at_ctx_pct", "leniency_floor_pct",
+    "plan_explicit_offload", "plan_flex", "plan_partial_offload",
+]