hyperagents 1.2.3rc5.post3__py3-none-any.whl

hyperclaw/connection_check.py

@@ -0,0 +1,113 @@
+"""Live check of HyperSpeed V2 right after the Hyper access key is entered.
+
+One tiny chat request (max_tokens 1) to the configured endpoint with that key.
+The screen gets "✓ Connected to HyperSpeed V2" or the plain reason it failed,
+in the failure-notice wording of hyperclaw.notices. The HTTP status is shown
+only with --verbose (HYPERCLAW_VERBOSE=1) and is always written to the log.
+"""
+from __future__ import annotations
+
+import logging
+import os
+from dataclasses import dataclass
+from typing import Optional
+
+from hyperclaw.notices import failure_notice, log_failure
+
+log = logging.getLogger("hyperclaw.connection_check")
+
+TIMEOUT_S = 15.0
+WHAT = "connect to HyperSpeed V2"
+
+OK = "ok"
+AUTH = "auth"
+UNAVAILABLE = "unavailable"
+TIMEOUT = "timeout"
+NO_KEY = "no_key"
+
+DETAIL = {
+    AUTH: ("HyperSpeed V2 didn't accept that access key. Check it with your Hyper contact; "
+           "you can enter it again with hyperclaw provider hyper-key."),
+    UNAVAILABLE: ("HyperSpeed V2 isn't available right now. Your key is saved; "
+                  "try again when it is available."),
+    TIMEOUT: ("HyperSpeed V2 didn't answer in time. Your key is saved; "
+              "try again when it is available."),
+    NO_KEY: "No Hyper access key was entered. Add it with hyperclaw provider hyper-key.",
+}
+
+
+def connected_line() -> str:
+    from hyperclaw import hyperspeed
+    return f"✓ Connected to {hyperspeed.LABEL}"
+
+
+@dataclass
+class CheckResult:
+    ok: bool
+    kind: str
+    status: Optional[int] = None
+    line: str = ""
+
+
+def _verbose() -> bool:
+    return os.environ.get("HYPERCLAW_VERBOSE", "").strip() == "1"
+
+
+def _failed(kind: str, technical: str, status: Optional[int] = None) -> CheckResult:
+    log_failure(log, "connect", technical, context="HyperSpeed V2 connection check")
+    detail = DETAIL[kind]
+    if _verbose() and technical:
+        detail = f"({technical}) {detail}"
+    return CheckResult(False, kind, status, failure_notice(what=WHAT, detail=detail,
+                                                            retry=False))
+
+
+def _default_transport():
+    """None = httpx's real transport. The test suite replaces this so no
+    test can reach a real endpoint."""
+    return None
+
+
+def check_hyperspeed(key: str, base_url: Optional[str] = None, model: Optional[str] = None,
+                     timeout: float = TIMEOUT_S, transport=None) -> CheckResult:
+    """Make one live call to HyperSpeed V2 with ``key``. ``transport`` is an
+    httpx transport (tests pass a mock; nothing else does)."""
+    import httpx
+    from hyperclaw import hyperspeed
+    key = (key or "").strip()
+    if not key:
+        return CheckResult(False, NO_KEY, None,
+                           failure_notice(what=WHAT, detail=DETAIL[NO_KEY], retry=False))
+    url = (base_url or hyperspeed.base_url()).rstrip("/") + "/chat/completions"
+    from hyperclaw.cost_guard import CostCapReached, max_output, metered
+    mid = model or hyperspeed.model()
+    body = {"model": mid, "max_tokens": max_output("connection_check", hyperspeed.PROVIDER_NAME, mid),
+            "messages": [{"role": "user", "content": "ping"}]}
+    try:
+        # The check is a real (one-token) model call, so it goes through the
+        # cost guard like every other call: preflight against the caps, then
+        # record the usage the endpoint reports.
+        with metered(hyperspeed.PROVIDER_NAME, body["model"], body, body["max_tokens"]) as m:
+            with httpx.Client(timeout=timeout,
+                              transport=transport or _default_transport()) as client:
+                r = client.post(url, json=body, headers={"Authorization": f"Bearer {key}"})
+            if 200 <= r.status_code < 300:
+                try:
+                    m.usage_from(r.json())
+                except ValueError:
+                    pass
+            else:
+                m.commit(failed=True)   # refused: nothing generated, release the reservation
+    except CostCapReached as e:
+        log_failure(log, "connect", "cost cap reached", context="HyperSpeed V2 connection check")
+        return CheckResult(False, UNAVAILABLE, None,
+                           failure_notice(what=WHAT, detail=e.headline(), retry=False))
+    except httpx.TimeoutException as e:
+        return _failed(TIMEOUT, f"timeout: {type(e).__name__}")
+    except httpx.HTTPError as e:
+        return _failed(UNAVAILABLE, type(e).__name__)
+    if 200 <= r.status_code < 300:
+        log.info("HyperSpeed V2 connection check passed (HTTP %s)", r.status_code)
+        return CheckResult(True, OK, r.status_code, connected_line())
+    kind = AUTH if r.status_code in (401, 403) else UNAVAILABLE
+    return _failed(kind, f"HTTP {r.status_code}", r.status_code)