hypernix 0.72.2.post3__tar.gz → 0.72.2.post5__tar.gz

{hypernix-0.72.2.post3 → hypernix-0.72.2.post5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypernix
-Version: 0.72.2.post3
+Version: 0.72.2.post5
 Summary: Download and quantize the HyperNix PyTorch model to GGUF (fp32/fp16/Q8_0/Q6_K/Q4_K_M).
 Home-page: https://github.com/minerofthesoal/hypernix-pip
 Author: HyperNix contributors

{hypernix-0.72.2.post3 → hypernix-0.72.2.post5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hypernix"
-version = "0.72.2.post3"
+version = "0.72.2.post5"
 description = "Download and quantize the HyperNix PyTorch model to GGUF (fp32/fp16/Q8_0/Q6_K/Q4_K_M)."
 readme = { file = "README.md", content-type = "text/markdown" }
 license = { text = "HOL-1.0" }

{hypernix-0.72.2.post3 → hypernix-0.72.2.post5}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = hypernix
-version = 0.72.2.post3
+version = 0.72.2.post5
 description = Download and quantize the HyperNix PyTorch model to GGUF (fp32/fp16/Q8_0/Q6_K/Q4_K_M).
 long_description = file: README.md
 long_description_content_type = text/markdown

{hypernix-0.72.2.post3 → hypernix-0.72.2.post5}/src/hypernix/__init__.py

@@ -63,7 +63,7 @@ import importlib.util
 import sys
 from typing import TYPE_CHECKING, Any
 
-__version__ = "0.72.2-3"
+__version__ = "0.72.2.post5"
 DEFAULT_REPO_ID = "ray0rf1re/hyper-Nix.2"
 DEFAULT_MODEL = "qwen3.5-4b"  # New default model
 

{hypernix-0.72.2.post3 → hypernix-0.72.2.post5}/src/hypernix/hyperlink/__init__.py

@@ -27,13 +27,15 @@ everything here is testable with no web layer in the way.
 """
 from __future__ import annotations
 
+# Derived rather than repeated — see hypernix.waiter.__init__ for why.
+from ..t1api.version import T1_VERSION_SHORT as _T1_VERSION_SHORT
 from .discovery import Endpoint, advertise, local_endpoints
 from .files import Attachment, AttachmentStore
 from .hfmerge import HFRef, HFResolveError, ResolvedModel, merge, parse_link, resolve
 from .pairing import DeviceRecord, DeviceRegistry, PairingCode, pairing_payload
 from .sessions import ChatMessage, ChatSession, ChatSessionStore
 
-__hyperlink_version__ = "1.0.26.8.1.0"
+__hyperlink_version__ = _T1_VERSION_SHORT
 
 __all__ = [
     "__hyperlink_version__",

{hypernix-0.72.2.post3 → hypernix-0.72.2.post5}/src/hypernix/security/keymaster.py

@@ -68,6 +68,7 @@ import threading
 import time
 import uuid
 import warnings
+from collections.abc import Iterable
 from dataclasses import dataclass
 from datetime import UTC, datetime
 from enum import StrEnum
@@ -157,6 +158,18 @@ def _format_server_id(seq: int, letter: str, gen: int) -> str:
     return f"{seq:05d}-{letter}{gen}"
 
 
+def _server_id_order(server_id: str) -> tuple[int, int, int]:
+    """Sort key for a server ID, in the order it actually advances.
+
+    ``_next_server_id`` bumps the sequence, rolls it into the letter, and
+    rolls the letter into the generation — so generation is the most
+    significant part and sequence the least. Sorting the raw strings would
+    put ``00002-A1`` after ``00001-B1``, which is backwards.
+    """
+    seq, letter, gen = _parse_server_id(server_id)
+    return (gen, ord(letter), seq)
+
+
 def _next_server_id(current: str) -> str:
     """Increment a server ID, cycling through A–Z then bumping the generation."""
     seq, letter, gen = _parse_server_id(current)
@@ -430,6 +443,7 @@ class Keymaster:
             )
 
         self._load_all()
+        self._resume_server_id(server_id)
 
         self._stop_event = threading.Event()
         self._bg_thread: threading.Thread | None = None
@@ -494,6 +508,60 @@ class Keymaster:
                 if meta:
                     self._keys[meta.key_id] = meta
 
+    def _resume_server_id(self, requested_start: str) -> None:
+        """Continue the server-ID sequence from what the store already holds.
+
+        The counter only ever lived in memory, so every process started
+        again at ``00001-A1`` — and since each ``gkey`` invocation is its
+        own process, every key ever minted from the CLI carried the same
+        server ID. The field was there, documented, and constant.
+
+        Archived keys are scanned too. ``_load_all`` reads only the active
+        store, and revoking a key moves it into ``archive/``; resuming
+        from the active keys alone would hand a revoked key's server ID to
+        a new key the moment the highest-numbered one was revoked. A
+        server ID that comes back around is worse than one that never
+        moves, because audit trails stop being able to tell the two keys
+        apart.
+
+        An explicitly requested start still wins when it is ahead of the
+        store, so a caller can move a fresh sequence forward on purpose.
+        """
+        highest: tuple[int, int, int] | None = None
+        highest_id = ""
+        paths = list(self._store.glob("*.json"))
+        paths.extend((self._store / _ARCHIVE_SUBDIR).glob("*.json"))
+        for path in paths:
+            if path.name.startswith("."):
+                continue
+            meta = self._load_file(path)
+            if meta is None or not meta.server_id:
+                continue
+            try:
+                order = _server_id_order(meta.server_id)
+            except ValueError:
+                # A hand-edited or truncated record must not stop the
+                # store from opening; it just does not advance anything.
+                logger.warning(
+                    "keymaster: ignoring unparseable server_id %r on key %s",
+                    meta.server_id,
+                    meta.key_id,
+                )
+                continue
+            if highest is None or order > highest:
+                highest, highest_id = order, meta.server_id
+
+        if highest is None:
+            return
+        resumed = _next_server_id(highest_id)
+        with self._lock:
+            try:
+                requested_order = _server_id_order(requested_start)
+            except ValueError:
+                requested_order = None
+            if requested_order is None or _server_id_order(resumed) > requested_order:
+                self._server_id = resumed
+
     # ------------------------------------------------------------------
     # Core CRUD
     # ------------------------------------------------------------------
@@ -554,6 +622,101 @@ class Keymaster:
                     return meta
         return None
 
+    # ------------------------------------------------------------------
+    # Reversal primitives
+    # ------------------------------------------------------------------
+    #
+    # The T1 API's auth undo/redo (POST /t1/auth/undo) reverses an
+    # operation by putting a key back the way it was. Each of these is one
+    # such inverse. They existed only as ``hasattr`` checks in the undo
+    # handler, which meant every undo answered 501 "this server's
+    # Keymaster cannot …" — a feature that could not work on any
+    # deployment, because no Keymaster had the methods.
+    #
+    # They are deliberately narrow. None of them creates or destroys a
+    # key, none changes a key's identity, and each writes exactly one
+    # field: an undo must land on a state the system could have reached
+    # forwards.
+
+    def restore_key(self, key_id: str, key_str: str) -> KeyMeta:
+        """Put previous key material back on an existing key.
+
+        Used to reverse a rotation. The key ID does not change — this is
+        the same record with its secret restored — so anything that
+        references the key by ID keeps working.
+        """
+        if not T1KeyGenerator.validate(key_str):
+            raise ValueError("Not a valid T1 key")
+        with self._lock:
+            meta = self._keys.get(key_id)
+            if meta is None:
+                raise KeyError(f"Key not found: {key_id!r}")
+            meta.key = key_str
+        self._save(meta)
+        logger.info("keymaster: restored key material on %s", key_id[:8])
+        return meta
+
+    def set_key_type(self, key_id: str, key_type: KeyType | str) -> KeyMeta:
+        """Change a key's type. Reverses a promotion."""
+        key_type = KeyType(key_type)
+        with self._lock:
+            meta = self._keys.get(key_id)
+            if meta is None:
+                raise KeyError(f"Key not found: {key_id!r}")
+            meta.key_type = key_type
+        self._save(meta)
+        logger.info("keymaster: set type of %s to %s", key_id[:8], key_type.value)
+        return meta
+
+    def set_scopes(self, key_id: str, scopes: Iterable[KeyScope | str]) -> KeyMeta:
+        """Replace a key's scope set. Reverses a scope change."""
+        resolved = {KeyScope(s) for s in scopes}
+        if not resolved:
+            raise ValueError("A key must keep at least one scope")
+        with self._lock:
+            meta = self._keys.get(key_id)
+            if meta is None:
+                raise KeyError(f"Key not found: {key_id!r}")
+            meta.scopes = resolved
+        self._save(meta)
+        logger.info("keymaster: set scopes of %s", key_id[:8])
+        return meta
+
+    def set_revoked(self, key_id: str, revoked: bool) -> KeyMeta:
+        """Revoke or un-revoke a key.
+
+        Un-revoking has to move the record back out of the archive, since
+        :meth:`revoke` archives rather than deletes — which is exactly what
+        makes the operation reversible at all.
+        """
+        if revoked:
+            with self._lock:
+                if key_id in self._keys:
+                    self.revoke(key_id)
+                    return self._load_file(self._archive_path(key_id))  # type: ignore[return-value]
+                archived = self._load_file(self._archive_path(key_id))
+            if archived is None:
+                raise KeyError(f"Key not found: {key_id!r}")
+            return archived
+
+        with self._lock:
+            if key_id in self._keys:
+                return self._keys[key_id]
+        meta = self._load_file(self._archive_path(key_id))
+        if meta is None:
+            raise KeyError(f"Key not found in the archive: {key_id!r}")
+        meta.active = True
+        meta.revoked_at = None
+        with self._lock:
+            self._keys[key_id] = meta
+        self._save(meta)
+        try:
+            self._archive_path(key_id).unlink()
+        except FileNotFoundError:
+            pass
+        logger.info("keymaster: un-revoked key %s", key_id[:8])
+        return meta
+
     def revoke(self, key_id: str, reason: str = "") -> None:
         """Revoke a key. It is archived but not deleted."""
         with self._lock:

{hypernix-0.72.2.post3 → hypernix-0.72.2.post5}/src/hypernix/t1api/auth.py

@@ -234,6 +234,23 @@ class T1AuthService:
                 details={"key_family": "T1", "accepted": self._accepted_families()},
                 http_status=401,
             )
+        return self._authenticate_with_reload(key_str)
+
+    def _authenticate_with_reload(self, key_str: str) -> AuthContext:
+        """Authenticate a T1 key, refreshing the store once if it is unknown.
+
+        A key created after this process started is not in the in-memory
+        table yet, so the first lookup misses and a refresh is worth one
+        try before calling it invalid.
+
+        Shared with the T2 path deliberately. It used to live inline in
+        :meth:`validate_key`, which meant :meth:`_validate_t2` — reaching
+        the store through :meth:`_validate_uncached` — never refreshed at
+        all. A T1 key minted against a running server worked; the *same
+        key* presented in its T2 or T2S spelling was refused until the
+        server restarted, which is as confusing a failure as this codebase
+        can produce: the key is real, registered, and correctly typed.
+        """
         try:
             meta = self.gatekeeper.authenticate(key_str)
         except (ValueError, PermissionError):
@@ -270,7 +287,45 @@ class T1AuthService:
             raise T1APIError(T1ErrorCode.AUTH_INVALID_KEY, str(exc), http_status=401) from exc
 
         equivalent = T2KeyGenerator.to_t1(parsed)
-        context = self._validate_uncached(equivalent)
+        try:
+            context = self._authenticate_with_reload(equivalent)
+        except T1APIError as exc:
+            # The underlying path only ever knew about T1 keys, so it says
+            # "Unknown or unregistered T1 key" to someone holding a T2S
+            # key — which reads as though the wrong *kind* of key was
+            # presented, when in fact the right kind simply is not in this
+            # server's key store.
+            #
+            # That distinction is the whole difficulty with a T2 key: it
+            # is a spelling of a T1 key, so it authenticates by being
+            # converted back and looked up. A T2 key generated on its own
+            # belongs to no key store and authenticates as nothing, no
+            # matter how well-formed it is. Saying so, and naming the
+            # command that mints a registered one, is the difference
+            # between a two-minute fix and an afternoon.
+            if exc.code is T1ErrorCode.AUTH_INVALID_KEY:
+                raise T1APIError(
+                    T1ErrorCode.AUTH_INVALID_KEY,
+                    f"This {parsed.family.value} key is well-formed but is not "
+                    f"registered on this server.",
+                    details={
+                        "key_family": parsed.family.value,
+                        "reason": "not_in_key_store",
+                        "explanation": (
+                            f"A {parsed.family.value} key is a spelling of a T1 key "
+                            "rather than a separate credential: it is converted back "
+                            "to its T1 form and looked up in the key store. A key "
+                            "generated on its own is in no key store and authenticates "
+                            "as nothing."
+                        ),
+                        "remedy": (
+                            "Mint one on the server: "
+                            f"gkey create -v {'v2short' if parsed.family is T2Type.T2S else 'v2'}"
+                        ),
+                    },
+                    http_status=401,
+                ) from exc
+            raise
         context.t2_family = parsed.family.value
         context.t2_access_level = parsed.access_level
         context.t2_is_admin = parsed.is_admin

{hypernix-0.72.2.post3 → hypernix-0.72.2.post5}/src/hypernix/t1api/deps.py

@@ -378,9 +378,48 @@ def require_hyperlink_admin(principal: HyperLinkPrincipal) -> HyperLinkPrincipal
             http_status=403,
         )
     if not principal.is_admin:
+        # A T2S key is never an administrator, and never can be: admin is
+        # carried by the password component in a T2 prefix, and the T2S
+        # format has no room for one — it is short enough to type, which
+        # is exactly why it must not carry administrative authority.
+        #
+        # Saying only "requires an admin key" sends that holder off to
+        # widen their key's scopes, which cannot work however many times
+        # they try. The property is in the format, not the grant.
+        family = ""
+        ctx = principal.auth_context
+        if ctx is not None:
+            family = ctx.t2_family
+        if family == "T2S":
+            raise T1APIError(
+                T1ErrorCode.AUTH_ADMIN_REQUIRED,
+                "A T2S key can never perform this operation. Pairing is admin-only, "
+                "and a T2S key is never an administrator by design.",
+                details={
+                    "key_family": "T2S",
+                    "reason": "t2s_is_never_admin",
+                    "explanation": (
+                        "Administrative authority rides on the password component of "
+                        "a T2 prefix. A T2S key has no password component — it is "
+                        "short enough to type by hand, which is why it must not carry "
+                        "admin. Widening the underlying key's scopes will not change "
+                        "this."
+                    ),
+                    "remedy": (
+                        "Mint the pairing code on the PC with an admin key "
+                        "(`waiter hyperlink pair`), then redeem the six-character "
+                        "code on the phone. Use the T2S key for everything after "
+                        "pairing."
+                    ),
+                },
+                http_status=403,
+            )
         raise T1APIError(
             T1ErrorCode.AUTH_ADMIN_REQUIRED,
-            "This HyperLink operation requires an admin T1 key.",
+            "This HyperLink operation requires an admin key.",
+            details={
+                "remedy": "gkey create --type admin --scopes admin,read,write",
+            },
             http_status=403,
         )
     return principal

{hypernix-0.72.2.post3 → hypernix-0.72.2.post5}/src/hypernix/t1api/routers/auth.py

@@ -1,8 +1,12 @@
 from __future__ import annotations
 
-from fastapi import APIRouter, Depends
+import logging
+from typing import Any
+
+from fastapi import APIRouter, Depends, Request
 
 from ..auth import AuthContext, T1AuthService
+from ..authhistory import AuthOp
 from ..deps import get_auth_context, get_auth_service, get_request_id, require_admin
 from ..schemas import (
     AdminRotateRequest,
@@ -13,6 +17,8 @@ from ..schemas import (
     ValidateKeyResponse,
 )
 
+logger = logging.getLogger(__name__)
+
 router = APIRouter(prefix="/auth", tags=["auth"])
 
 
@@ -50,14 +56,63 @@ def issue_token(
     )
 
 
+def _record_rotation(
+    request: Request,
+    *,
+    actor: str,
+    previous_key: str,
+    new_meta: Any,
+    previous_type: str = "",
+) -> None:
+    """Write a rotation into the auth history so it can be undone.
+
+    Without this, ``POST /t1/auth/undo`` has nothing to work with: the
+    history was only ever read, never written, so it was permanently
+    empty and every undo answered "nothing to undo". The endpoint
+    existed, the storage existed, and no operation ever put anything in
+    it.
+
+    Recorded against the *new* key ID, because that is the record the
+    inverse acts on — restoring the previous material onto it puts the
+    caller back where they were without changing any key ID, which is what
+    keeps references to the key valid across an undo.
+
+    Best-effort on purpose. The rotation has already happened and its new
+    key is in the response; failing the request now would tell the caller
+    their rotation failed when it did not, and lose the key with it.
+    """
+    history = getattr(request.app.state, "t1_auth_history", None)
+    if history is None:
+        return
+    payload = {"previous_key": previous_key, "new_key": new_meta.key}
+    if previous_type:
+        payload["previous_type"] = previous_type
+        payload["new_type"] = new_meta.key_type.value
+    try:
+        history.record(
+            AuthOp.ROTATE,
+            actor=actor,
+            target_key_id=new_meta.key_id,
+            payload=payload,
+            summary=f"rotated {new_meta.key_id[:8]}…",
+        )
+    except Exception:  # noqa: BLE001
+        logger.warning("t1api.auth: could not record the rotation", exc_info=True)
+
+
 @router.post("/t1/rotate", response_model=RotateResponse)
 def rotate_own_key(
+    request: Request,
     ctx: AuthContext = Depends(get_auth_context),
     svc: T1AuthService = Depends(get_auth_service),
     request_id: str = Depends(get_request_id),
 ) -> RotateResponse:
     """A caller may always rotate the key/token they authenticated with."""
+    previous_key = ctx.key_meta.key
     new_meta = svc.rotate_own_key(ctx.key_id)
+    _record_rotation(
+        request, actor=ctx.key_id, previous_key=previous_key, new_meta=new_meta
+    )
     return RotateResponse(
         key_id=new_meta.key_id,
         key=new_meta.key,
@@ -70,15 +125,28 @@ def rotate_own_key(
 
 @router.post("/t1/admin/rotate", response_model=RotateResponse)
 def admin_rotate(
+    request: Request,
     body: AdminRotateRequest,
     ctx: AuthContext = Depends(get_auth_context),
     svc: T1AuthService = Depends(get_auth_service),
     request_id: str = Depends(get_request_id),
 ) -> RotateResponse:
     require_admin(ctx)
+    keymaster = getattr(request.app.state, "t1_keymaster", None)
+    target = keymaster.get(body.target_key_id) if keymaster is not None else None
+    previous_key = target.key if target is not None else ""
+    previous_type = target.key_type.value if target is not None else ""
     new_meta = svc.admin_rotate(
         requester=ctx, target_key_id=body.target_key_id, promote_to_admin=body.promote_to_admin
     )
+    if previous_key:
+        _record_rotation(
+            request,
+            actor=ctx.key_id,
+            previous_key=previous_key,
+            new_meta=new_meta,
+            previous_type=previous_type if body.promote_to_admin else "",
+        )
     return RotateResponse(
         key_id=new_meta.key_id,
         key=new_meta.key,

{hypernix-0.72.2.post3 → hypernix-0.72.2.post5}/src/hypernix/t1api/routers/authundo.py

@@ -58,6 +58,31 @@ def _applier(request: Request):
     directory = getattr(request.app.state, "t1_key_directory", None)
 
     def apply(entry: Any, *, direction: str) -> None:
+        """Put a key back the way it was, or forward again.
+
+        Wrapped so that a key which no longer exists produces a refusal
+        rather than a bare 500. It is a reachable state, not a programming
+        error: the history outlives the keys it refers to, so undoing a
+        rotation whose key has since been revoked is an ordinary thing for
+        an operator to try, and "Internal Server Error" with no code and
+        no body is the least useful possible answer to it.
+        """
+        try:
+            _apply_inner(entry, direction=direction)
+        except KeyError as exc:
+            raise T1APIError(
+                T1ErrorCode.NOT_FOUND,
+                f"The key this {entry.op.value} applied to no longer exists, so it "
+                "cannot be reversed. The history entry is left in place.",
+                details={
+                    "target_key_id": entry.target_key_id,
+                    "op": entry.op.value,
+                    "direction": direction,
+                },
+                http_status=409,
+            ) from exc
+
+    def _apply_inner(entry: Any, *, direction: str) -> None:
         payload = entry.payload
         # "undo" restores the previous value; "redo" re-applies the new
         # one. Choosing the field by direction is the whole of it — the

{hypernix-0.72.2.post3 → hypernix-0.72.2.post5}/src/hypernix/t1api/version.py

@@ -267,9 +267,14 @@ def parse_version(text: str) -> T1Version:
 
 
 #: The version this build of the T1 API implements.
-T1_VERSION = T1Version(api=1, major=0, year=2026, month=8, feature=1, fix=0)
-T1_VERSION_SHORT = T1_VERSION.short   # "1.0.26.8.0.1"
-T1_VERSION_LONG = T1_VERSION.long     # "1.0.2026.8.0.1"
+#:
+#: 1.0.2026.8.1.1 is a fix bump inside the 1.0.2026.8.1 feature release:
+#: auth undo/redo now actually functions. It shipped with the history
+#: never being written to and the Keymaster missing every method the
+#: inverse needed, so the endpoints existed and could not work.
+T1_VERSION = T1Version(api=1, major=0, year=2026, month=8, feature=1, fix=1)
+T1_VERSION_SHORT = T1_VERSION.short   # "1.0.26.8.1.1"
+T1_VERSION_LONG = T1_VERSION.long     # "1.0.2026.8.1.1"
 
 #: Oldest client this server still answers without a compatibility
 #: warning. Same generation, first release of it — everything from the

{hypernix-0.72.2.post3 → hypernix-0.72.2.post5}/src/hypernix/t1sdk/__init__.py

@@ -44,6 +44,14 @@ written against.
 """
 from __future__ import annotations
 
+# Tracks the T1 API's own version (t1api/version.py), not the hypernix
+# package's: the SDK implements an API contract, and its version should
+# say which one.
+# Derived from the API's own version rather than repeated. Importing it
+# costs nothing the SDK was not already paying: hypernix.t1api.version is
+# pure stdlib, so this does not drag the [t1api] server extra into a
+# client that deliberately does without it.
+from ..t1api.version import T1_VERSION_SHORT as _T1_VERSION_SHORT
 from .client import T1Client
 from .errors import (
     T1AuthError,
@@ -69,10 +77,7 @@ from .models import (
 )
 from .transport import HTTPTransport, Response, RetryPolicy, TLSConfig
 
-# Tracks the T1 API's own version (t1api/version.py), not the hypernix
-# package's: the SDK implements an API contract, and its version should
-# say which one.
-__sdk_version__ = "1.0.26.8.1.0"
+__sdk_version__ = _T1_VERSION_SHORT
 
 __all__ = [
     "__sdk_version__",

{hypernix-0.72.2.post3 → hypernix-0.72.2.post5}/src/hypernix/waiter/__init__.py

@@ -25,6 +25,12 @@ new surfaces: ``waiter lmstudio`` (the LM Studio bridge),
 """
 from __future__ import annotations
 
-__waiter_version__ = "1.0.26.8.1.0"
+# Derived, never typed. waiter's protocol version *is* the T1 API's, so a
+# literal here is a second copy that drifts — which is exactly what
+# happened to the T1 version in `waiter --help`, left advertising
+# 1.0.26.8.0.1 two releases after the API had moved on.
+from ..t1api.version import T1_VERSION_SHORT as _T1_VERSION_SHORT
+
+__waiter_version__ = _T1_VERSION_SHORT
 
 __all__ = ["__waiter_version__"]

{hypernix-0.72.2.post3 → hypernix-0.72.2.post5}/src/hypernix/waiter/discovery.py

@@ -55,6 +55,8 @@ from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass, field
 from typing import Any
 
+from ..t1api.version import T1_VERSION_SHORT
+
 logger = logging.getLogger(__name__)
 
 __all__ = [
@@ -359,7 +361,11 @@ class DiscoveredServer:
 
 def _get(url: str, timeout: float) -> tuple[int, str]:
     req = urllib.request.Request(
-        url, headers={"Accept": "application/json", "User-Agent": "waiter-find/1.0.26.8.1.0"}
+        url,
+        headers={
+            "Accept": "application/json",
+            "User-Agent": f"waiter-find/{T1_VERSION_SHORT}",
+        },
     )
     try:
         with urllib.request.urlopen(req, timeout=timeout) as resp:  # noqa: S310
@@ -621,7 +627,7 @@ def connect(
                 "would be executing code chosen by the machine you are connecting to. "
                 "Start it yourself if you trust this host."
             )
-    if server.descriptor and not server.descriptor.supports_t1("1.0.26.8.1.0"):
+    if server.descriptor and not server.descriptor.supports_t1(T1_VERSION_SHORT):
         connection.notes.append(
             "This host advertises a T1 generation this client does not speak "
             f"({', '.join(server.descriptor.t1_versions)}); the connection may not work."

{hypernix-0.72.2.post3 → hypernix-0.72.2.post5}/src/hypernix.egg-info/SOURCES.txt

@@ -310,6 +310,7 @@ tests/test_quantize_v0703.py
 tests/test_ranges.py
 tests/test_shakers_and_torchcompat.py
 tests/test_snapshot_roundtrip.py
+tests/test_t1_v1_0_26_8_1_1.py
 tests/test_t1_v1_0_26_core.py
 tests/test_t1_v1_0_26_http.py
 tests/test_t1api_auth.py
@@ -328,6 +329,7 @@ tests/test_t1api_modules.py
 tests/test_t1api_routing.py
 tests/test_t1api_security.py
 tests/test_t1api_servers.py
+tests/test_t2s_errors.py
 tests/test_tupperware.py
 tests/test_tvtop_plus_plus_comprehensive.py
 tests/test_ups.py