hypercli-sdk 2026.4.9__tar.gz → 2026.4.13__tar.gz

{hypercli_sdk-2026.4.9 → hypercli_sdk-2026.4.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypercli-sdk
-Version: 2026.4.9
+Version: 2026.4.13
 Summary: Python SDK for HyperCLI - GPU orchestration and HyperAgent API
 Project-URL: Homepage, https://hypercli.com
 Project-URL: Documentation, https://docs.hypercli.com
@@ -132,6 +132,19 @@ response = client.chat.completions.create(
 )
 ```
 
+## OpenClaw Agents
+
+OpenClaw uses the generic deployment launch surface. `registry_url`, `registry_auth`, `sync_root`, and `sync_enabled` are generic deployment options; the OpenClaw helpers only add defaults such as routes, image, and `sync_root=/home/node`.
+
+```python
+agent = client.deployments.create_openclaw(
+    name="docs-demo",
+    start=True,
+    registry_url="git.nedos.co",
+    registry_auth={"username": "ci", "password": "token"},
+)
+```
+
 ## Error Handling
 
 ```python

{hypercli_sdk-2026.4.9 → hypercli_sdk-2026.4.13}/README.md

@@ -101,6 +101,19 @@ response = client.chat.completions.create(
 )
 ```
 
+## OpenClaw Agents
+
+OpenClaw uses the generic deployment launch surface. `registry_url`, `registry_auth`, `sync_root`, and `sync_enabled` are generic deployment options; the OpenClaw helpers only add defaults such as routes, image, and `sync_root=/home/node`.
+
+```python
+agent = client.deployments.create_openclaw(
+    name="docs-demo",
+    start=True,
+    registry_url="git.nedos.co",
+    registry_auth={"username": "ci", "password": "token"},
+)
+```
+
 ## Error Handling
 
 ```python

{hypercli_sdk-2026.4.9 → hypercli_sdk-2026.4.13}/hypercli/__init__.py

@@ -43,6 +43,8 @@ from .agent import (
     HyperAgent,
     HyperAgentPlan,
     HyperAgentCurrentPlan,
+    HyperAgentEntitlements,
+    HyperAgentEntitlementsSummary,
     HyperAgentSubscription,
     HyperAgentSubscriptionSummary,
     HyperAgentModel,
@@ -58,7 +60,7 @@ from .gateway import (
     extract_gateway_chat_tool_calls,
     normalize_gateway_chat_message,
 )
-__version__ = "2026.4.7"
+__version__ = "2026.4.13"
 __all__ = [
     "HyperCLI",
     "configure",
@@ -141,6 +143,8 @@ __all__ = [
     "HyperAgent",
     "HyperAgentPlan",
     "HyperAgentCurrentPlan",
+    "HyperAgentEntitlements",
+    "HyperAgentEntitlementsSummary",
     "HyperAgentSubscription",
     "HyperAgentSubscriptionSummary",
     "HyperAgentModel",

{hypercli_sdk-2026.4.9 → hypercli_sdk-2026.4.13}/hypercli/agent.py

@@ -85,7 +85,7 @@ class HyperAgentCurrentPlan:
 
 @dataclass
 class HyperAgentSubscription:
-    """A purchased HyperClaw entitlement/subscription instance."""
+    """A recurring HyperClaw billing subscription."""
 
     id: str
     user_id: str
@@ -106,10 +106,11 @@ class HyperAgentSubscription:
     plan_tpd: int = 0
     plan_agent_tier: str | None = None
     slot_grants: dict[str, int] | None = None
+    entitlements: list["HyperAgentEntitlement"] | None = None
 
     @classmethod
     def from_dict(cls, data: dict) -> "HyperAgentSubscription":
-        expires_at = data.get("expires_at")
+        expires_at = data.get("current_period_end", data.get("expires_at"))
         updated_at = data.get("updated_at")
         return cls(
             id=data["id"],
@@ -131,6 +132,92 @@ class HyperAgentSubscription:
             plan_tpd=int(data.get("plan_tpd", 0) or 0),
             plan_agent_tier=data.get("plan_agent_tier"),
             slot_grants=data.get("slot_grants") or None,
+            entitlements=[HyperAgentEntitlement.from_dict(item) for item in data.get("entitlements", [])] or None,
+        )
+
+
+@dataclass
+class HyperAgentEntitlement:
+    """A concrete 1:1 entitlement grant."""
+
+    id: str
+    user_id: str
+    subscription_id: str | None
+    plan_id: str
+    plan_name: str
+    provider: str
+    status: str
+    expires_at: datetime | None = None
+    updated_at: datetime | None = None
+    tpm_limit: int = 0
+    rpm_limit: int = 0
+    tpd_limit: int = 0
+    agent_tier: str | None = None
+    features: dict[str, bool] | None = None
+    tags: list[str] | None = None
+    meta: dict[str, Any] | None = None
+    slot_grants: dict[str, int] | None = None
+    active_agent_count: int = 0
+    active_agent_ids: list[str] | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "HyperAgentEntitlement":
+        expires_at = data.get("expires_at")
+        updated_at = data.get("updated_at")
+        return cls(
+            id=data["id"],
+            user_id=data.get("user_id", ""),
+            subscription_id=data.get("subscription_id"),
+            plan_id=data.get("plan_id", ""),
+            plan_name=data.get("plan_name", data.get("plan_id", "")),
+            provider=data.get("provider", ""),
+            status=data.get("status", ""),
+            expires_at=datetime.fromisoformat(str(expires_at).replace("Z", "+00:00")) if expires_at else None,
+            updated_at=datetime.fromisoformat(str(updated_at).replace("Z", "+00:00")) if updated_at else None,
+            tpm_limit=int(data.get("tpm_limit", 0) or 0),
+            rpm_limit=int(data.get("rpm_limit", 0) or 0),
+            tpd_limit=int(data.get("tpd_limit", 0) or 0),
+            agent_tier=data.get("agent_tier"),
+            features=data.get("features") or {},
+            tags=data.get("tags") or [],
+            meta=data.get("meta") or None,
+            slot_grants=data.get("slot_grants") or None,
+            active_agent_count=int(data.get("active_agent_count", 0) or 0),
+            active_agent_ids=data.get("active_agent_ids") or [],
+        )
+
+
+@dataclass
+class HyperAgentEntitlements:
+    """Effective account entitlements computed by the backend."""
+
+    effective_plan_id: str
+    pooled_tpm_limit: int
+    pooled_rpm_limit: int
+    pooled_tpd: int
+    slot_inventory: dict[str, Any]
+    active_entitlement_count: int
+    billing_reset_at: datetime | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "HyperAgentEntitlements":
+        payload = data.get("entitlements") if isinstance(data.get("entitlements"), dict) else data
+        return cls(
+            effective_plan_id=payload.get("effective_plan_id", data.get("effective_plan_id", "")),
+            pooled_tpm_limit=int(payload.get("pooled_tpm_limit", data.get("pooled_tpm_limit", 0)) or 0),
+            pooled_rpm_limit=int(payload.get("pooled_rpm_limit", data.get("pooled_rpm_limit", 0)) or 0),
+            pooled_tpd=int(payload.get("pooled_tpd", data.get("pooled_tpd", 0)) or 0),
+            slot_inventory=payload.get("slot_inventory") or data.get("slot_inventory") or {},
+            active_entitlement_count=int(
+                payload.get(
+                    "active_entitlement_count",
+                    data.get("active_entitlement_count", data.get("active_subscription_count", 0)),
+                )
+                or 0
+            ),
+            billing_reset_at=datetime.fromisoformat(str(payload.get("billing_reset_at")).replace("Z", "+00:00"))
+            if payload.get("billing_reset_at")
+            else None,
         )
 
 
@@ -140,11 +227,16 @@ class HyperAgentSubscriptionSummary:
 
     effective_plan_id: str
     current_subscription_id: str | None
+    current_entitlement_id: str | None
     pooled_tpm_limit: int
     pooled_rpm_limit: int
     pooled_tpd: int
     slot_inventory: dict[str, Any]
+    billing_reset_at: datetime | None
     active_subscription_count: int
+    active_entitlement_count: int
+    entitlements: HyperAgentEntitlements
+    entitlement_items: list[HyperAgentEntitlement]
     active_subscriptions: list[HyperAgentSubscription]
     subscriptions: list[HyperAgentSubscription]
     user: dict[str, Any]
@@ -154,17 +246,42 @@ class HyperAgentSubscriptionSummary:
         return cls(
             effective_plan_id=data.get("effective_plan_id", ""),
             current_subscription_id=data.get("current_subscription_id"),
+            current_entitlement_id=data.get("current_entitlement_id", data.get("current_subscription_id")),
             pooled_tpm_limit=int(data.get("pooled_tpm_limit", 0) or 0),
             pooled_rpm_limit=int(data.get("pooled_rpm_limit", 0) or 0),
             pooled_tpd=int(data.get("pooled_tpd", 0) or 0),
             slot_inventory=data.get("slot_inventory") or {},
+            billing_reset_at=datetime.fromisoformat(str(data.get("billing_reset_at")).replace("Z", "+00:00"))
+            if data.get("billing_reset_at")
+            else None,
             active_subscription_count=int(data.get("active_subscription_count", 0) or 0),
+            active_entitlement_count=int(data.get("active_entitlement_count", data.get("active_subscription_count", 0)) or 0),
+            entitlements=HyperAgentEntitlements.from_dict(data),
+            entitlement_items=[HyperAgentEntitlement.from_dict(item) for item in data.get("entitlement_items", [])],
             active_subscriptions=[HyperAgentSubscription.from_dict(item) for item in data.get("active_subscriptions", [])],
             subscriptions=[HyperAgentSubscription.from_dict(item) for item in data.get("subscriptions", [])],
             user=data.get("user") or {},
         )
 
 
+HyperAgentEntitlementsSummary = HyperAgentSubscriptionSummary
+
+
+@dataclass
+class HyperAgentSubscriptionMutationResult:
+    ok: bool
+    message: str
+    subscription: HyperAgentSubscription | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "HyperAgentSubscriptionMutationResult":
+        return cls(
+            ok=bool(data.get("ok", False)),
+            message=str(data.get("message") or ""),
+            subscription=HyperAgentSubscription.from_dict(data["subscription"]) if data.get("subscription") else None,
+        )
+
+
 @dataclass
 class HyperAgentModel:
     """Available model on HyperAgent."""
@@ -368,6 +485,35 @@ class HyperAgent:
         response.raise_for_status()
         return HyperAgentSubscriptionSummary.from_dict(response.json())
 
+    def entitlements(self) -> HyperAgentEntitlementsSummary:
+        response = self._http._session.get(
+            f"{self._control_base_url}/entitlements",
+            headers={"Authorization": f"Bearer {self._api_key}"},
+        )
+        response.raise_for_status()
+        return HyperAgentEntitlementsSummary.from_dict(response.json())
+
+    def entitlement_instances(self) -> list[HyperAgentEntitlement]:
+        response = self._http._session.get(
+            f"{self._control_base_url}/entitlements/instances",
+            headers={"Authorization": f"Bearer {self._api_key}"},
+        )
+        response.raise_for_status()
+        data = response.json()
+        return [HyperAgentEntitlement.from_dict(item) for item in data.get("items", [])]
+
+    def update_subscription(self, subscription_id: str, bundle: dict[str, int] | None) -> HyperAgentSubscriptionMutationResult:
+        response = self._http._session.post(
+            f"{self._control_base_url}/subscriptions/{subscription_id}/update",
+            headers={"Authorization": f"Bearer {self._api_key}"},
+            json={"bundle": dict(bundle or {})},
+        )
+        response.raise_for_status()
+        return HyperAgentSubscriptionMutationResult.from_dict(response.json())
+
+    def cancel_subscription(self, subscription_id: str) -> HyperAgentSubscriptionMutationResult:
+        return self.update_subscription(subscription_id, {})
+
     def discovery_health(self) -> Dict[str, Any]:
         response = self._http._session.get(f"{self._api_base_without_v1()}/discovery/health")
         response.raise_for_status()

{hypercli_sdk-2026.4.9 → hypercli_sdk-2026.4.13}/hypercli/agents.py

@@ -32,7 +32,7 @@ DEV_AGENTS_API_BASE = "https://api.dev.hypercli.com/agents"
 DEV_AGENTS_WS_URL = "wss://api.agents.dev.hypercli.com/ws"
 DEFAULT_OPENCLAW_IMAGE = "ghcr.io/hypercli/hypercli-openclaw:prod"
 LAUNCH_CONFIG_KEYS = frozenset({"image", "env", "routes", "ports", "command", "entrypoint", "sync_root", "sync_enabled", "registry_url", "registry_auth"})
-DEFAULT_OPENCLAW_SYNC_ROOT = "/home/ubuntu"
+DEFAULT_OPENCLAW_SYNC_ROOT = "/home/node"
 
 
 def _is_directory_listing_payload(value: object) -> bool:
@@ -391,8 +391,6 @@ class Agent:
         *,
         name: str | None = None,
         size: str | None = None,
-        cpu: float | None = None,
-        memory: int | None = None,
         refresh_from_lagoon: bool | None = None,
         last_error: str | None = None,
     ) -> "Agent":
@@ -400,8 +398,6 @@ class Agent:
             self.id,
             name=name,
             size=size,
-            cpu=cpu,
-            memory=memory,
             refresh_from_lagoon=refresh_from_lagoon,
             last_error=last_error,
         )
@@ -409,8 +405,8 @@ class Agent:
         self._deployments = agent._deployments
         return self
 
-    def resize(self, *, size: str | None = None, cpu: float | None = None, memory: int | None = None) -> "Agent":
-        return self.update(size=size, cpu=cpu, memory=memory)
+    def resize(self, *, size: str | None = None) -> "Agent":
+        return self.update(size=size)
 
     def env(self) -> dict[str, str]:
         """Fetch runtime environment from the pod's K8s secret."""
@@ -1006,8 +1002,6 @@ class Deployments:
         self,
         name: str = None,
         size: str = None,
-        cpu: int = None,
-        memory: int = None,
         config: dict = None,
         tags: list[str] = None,
         env: dict = None,
@@ -1030,8 +1024,6 @@ class Deployments:
         Args:
             name: Agent name.
             size: Size preset (small/medium/large). Default: medium.
-            cpu: Custom CPU in cores (overrides size).
-            memory: Custom memory in GB (overrides size).
             config: Optional config overrides.
             env: Optional environment variables to pass through to the pod.
             ports: Optional exposed ports config.
@@ -1061,10 +1053,6 @@ class Deployments:
             body["name"] = name
         if size:
             body["size"] = size
-        if cpu is not None:
-            body["cpu"] = cpu
-        if memory is not None:
-            body["memory"] = memory
         if meta_ui:
             body["meta"] = {"ui": copy.deepcopy(meta_ui)}
         if tags:
@@ -1082,8 +1070,6 @@ class Deployments:
         self,
         name: str = None,
         size: str = None,
-        cpu: int = None,
-        memory: int = None,
         config: dict = None,
         tags: list[str] = None,
         env: dict = None,
@@ -1103,14 +1089,13 @@ class Deployments:
         openclaw_routes: dict | None = None,
         openclaw_route_options: dict | None = None,
     ) -> Agent:
+        effective_env = dict(env or {})
         return self.create(
             name=name,
             size=size,
-            cpu=cpu,
-            memory=memory,
             config=config,
             tags=tags,
-            env=env,
+            env=effective_env,
             ports=ports,
             routes=_resolve_openclaw_routes(
                 routes,
@@ -1255,10 +1240,11 @@ class Deployments:
         openclaw_routes: dict | None = None,
         openclaw_route_options: dict | None = None,
     ) -> Agent:
+        effective_env = dict(env or {})
         return self.start(
             agent_id,
             config=config,
-            env=env,
+            env=effective_env,
             ports=ports,
             routes=_resolve_openclaw_routes(
                 routes,
@@ -1282,8 +1268,6 @@ class Deployments:
         *,
         name: str | None = None,
         size: str | None = None,
-        cpu: float | None = None,
-        memory: int | None = None,
         refresh_from_lagoon: bool | None = None,
         last_error: str | None = None,
     ) -> Agent:
@@ -1292,10 +1276,6 @@ class Deployments:
             body["name"] = name
         if size is not None:
             body["size"] = size
-        if cpu is not None:
-            body["cpu"] = cpu
-        if memory is not None:
-            body["memory"] = memory
         if refresh_from_lagoon is not None:
             body["refresh_from_lagoon"] = refresh_from_lagoon
         if last_error is not None:
@@ -1308,10 +1288,8 @@ class Deployments:
         agent_id: str,
         *,
         size: str | None = None,
-        cpu: float | None = None,
-        memory: int | None = None,
     ) -> Agent:
-        return self.update(agent_id, size=size, cpu=cpu, memory=memory)
+        return self.update(agent_id, size=size)
 
     def stop(self, agent_id: str) -> Agent:
         """Stop an agent (tears down pod, keeps DB record).

hypercli_sdk-2026.4.13/hypercli/gateway.py

@@ -0,0 +1,7 @@
+"""Backward-compatible module alias for OpenClaw gateway surfaces."""
+
+import sys
+
+from .openclaw import gateway as _gateway
+
+sys.modules[__name__] = _gateway

hypercli_sdk-2026.4.13/hypercli/openclaw/__init__.py

@@ -0,0 +1,25 @@
+"""OpenClaw-specific SDK surfaces."""
+
+from .gateway import (
+    GatewayClient,
+    GatewayError,
+    ChatEvent,
+    GatewayChatToolCall,
+    GatewayChatMessageSummary,
+    extract_gateway_chat_thinking,
+    extract_gateway_chat_media_urls,
+    extract_gateway_chat_tool_calls,
+    normalize_gateway_chat_message,
+)
+
+__all__ = [
+    "GatewayClient",
+    "GatewayError",
+    "ChatEvent",
+    "GatewayChatToolCall",
+    "GatewayChatMessageSummary",
+    "extract_gateway_chat_thinking",
+    "extract_gateway_chat_media_urls",
+    "extract_gateway_chat_tool_calls",
+    "normalize_gateway_chat_message",
+]

{hypercli_sdk-2026.4.9/hypercli → hypercli_sdk-2026.4.13/hypercli/openclaw}/gateway.py

@@ -14,12 +14,13 @@ import base64
 import hashlib
 import json
 import os
+import shlex
 import time
 import uuid
 from dataclasses import asdict, dataclass
 from pathlib import Path
 from typing import Any, AsyncIterator, Callable, Literal, Optional
-from urllib.parse import parse_qsl, quote, urlsplit
+from urllib.parse import parse_qsl, quote, urlsplit, urlunsplit
 
 import httpx
 import websockets
@@ -815,6 +816,10 @@ class GatewayClient:
             raise RuntimeError(
                 "auto_approve_pairing requires deployment_id, api_key, and api_base"
             )
+        command = (
+            "openclaw devices approve "
+            f"{shlex.quote(request_id)} --json"
+        )
         async with httpx.AsyncClient(timeout=30) as client:
             response = await client.post(
                 f"{self.api_base}/deployments/{quote(self.deployment_id or '')}/exec",
@@ -823,7 +828,7 @@ class GatewayClient:
                     "Content-Type": "application/json",
                 },
                 json={
-                    "command": f"openclaw devices approve {request_id}",
+                    "command": command,
                     "timeout": 30,
                 },
             )

{hypercli_sdk-2026.4.9 → hypercli_sdk-2026.4.13}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hypercli-sdk"
-version = "2026.4.9"
+version = "2026.4.13"
 description = "Python SDK for HyperCLI - GPU orchestration and HyperAgent API"
 readme = "README.md"
 requires-python = ">=3.10"

{hypercli_sdk-2026.4.9 → hypercli_sdk-2026.4.13}/tests/test_agents.py

@@ -520,8 +520,6 @@ def test_agents_create_returns_openclaw_agent(agents_client):
         agent = agents_client.create(
             name="test-agent",
             size="medium",
-            cpu=4,
-            memory=16,
             meta_ui={
                 "avatar": {
                     "image": "data:image/png;base64,xyz",
@@ -584,8 +582,9 @@ def test_create_openclaw_defaults_sync_root(agents_client):
         agents_client.create_openclaw(name="test-agent")
 
         posted_json = mock_client.post.call_args[1]["json"]
-        assert posted_json["sync_root"] == "/home/ubuntu"
+        assert posted_json["sync_root"] == "/home/node"
         assert posted_json["sync_enabled"] is True
+        assert "HOME" not in posted_json["env"]
 
 
 def test_start_openclaw_defaults_sync_root(agents_client):
@@ -609,8 +608,9 @@ def test_start_openclaw_defaults_sync_root(agents_client):
         agents_client.start_openclaw("agent-123")
 
         posted_json = mock_client.post.call_args[1]["json"]
-        assert posted_json["sync_root"] == "/home/ubuntu"
+        assert posted_json["sync_root"] == "/home/node"
         assert posted_json["sync_enabled"] is True
+        assert "HOME" not in posted_json["env"]
 
 
 def test_agents_get_returns_generic_agent_without_gateway_metadata(agents_client):
@@ -879,6 +879,7 @@ def test_agents_start_preserves_generic_launch_fields(agents_client):
             image="python:3.12-alpine",
             command=["sh", "-c", "python -m http.server 80"],
             routes={"web": {"port": 80, "auth": False, "prefix": ""}},
+            sync_root="/workspace",
             sync_enabled=True,
         )
 
@@ -887,6 +888,7 @@ def test_agents_start_preserves_generic_launch_fields(agents_client):
         assert posted_json["image"] == "python:3.12-alpine"
         assert posted_json["command"] == ["sh", "-c", "python -m http.server 80"]
         assert posted_json["routes"] == {"web": {"port": 80, "auth": False, "prefix": ""}}
+        assert posted_json["sync_root"] == "/workspace"
         assert posted_json["sync_enabled"] is True
 
 

hypercli_sdk-2026.4.13/tests/test_bootstrap_console_test_key.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import importlib.util
+import sys
+import types
+from pathlib import Path
+
+import pytest
+
+try:
+    import requests as _requests
+except ModuleNotFoundError:
+    _requests = types.ModuleType("requests")
+
+    class _ReadTimeout(Exception):
+        pass
+
+    class _ConnectionError(Exception):
+        pass
+
+    _requests.exceptions = types.SimpleNamespace(
+        ReadTimeout=_ReadTimeout,
+        Timeout=_ReadTimeout,
+        ConnectionError=_ConnectionError,
+    )
+    _requests.request = lambda *_args, **_kwargs: None  # pragma: no cover
+
+sys.modules.setdefault("requests", _requests)
+
+
+SCRIPT_PATH = Path(__file__).resolve().parents[2] / ".github" / "scripts" / "bootstrap_console_test_key.py"
+SPEC = importlib.util.spec_from_file_location("bootstrap_console_test_key", SCRIPT_PATH)
+assert SPEC and SPEC.loader
+MODULE = importlib.util.module_from_spec(SPEC)
+sys.modules[SPEC.name] = MODULE
+SPEC.loader.exec_module(MODULE)
+
+
+class _FakeResponse:
+    def __init__(self, status_code: int, payload: dict | list | None = None, text: str = "") -> None:
+        self.status_code = status_code
+        self._payload = payload if payload is not None else {}
+        self.text = text
+
+    def json(self):
+        return self._payload
+
+
+def test_request_retries_transient_timeout(monkeypatch: pytest.MonkeyPatch) -> None:
+    calls: list[int] = []
+
+    def fake_request(*_args, **_kwargs):
+        calls.append(1)
+        if len(calls) == 1:
+            raise _requests.exceptions.ReadTimeout("timed out")
+        return _FakeResponse(200, {"ok": True})
+
+    monkeypatch.setattr(MODULE.requests, "request", fake_request)
+    monkeypatch.setattr(MODULE.time, "sleep", lambda _seconds: None)
+
+    response = MODULE._request("GET", "https://example.test/api/admin/users")
+
+    assert response.status_code == 200
+    assert len(calls) == 2
+
+
+def test_create_user_returns_existing_user_after_conflict(monkeypatch: pytest.MonkeyPatch) -> None:
+    responses = [
+        _FakeResponse(409, text="User already exists"),
+        _FakeResponse(200, [{"user_id": "console-e2e-existing", "email": "console@example.com"}]),
+    ]
+
+    def fake_request(*_args, **_kwargs):
+        return responses.pop(0)
+
+    monkeypatch.setattr(MODULE.requests, "request", fake_request)
+    monkeypatch.setattr(MODULE.time, "sleep", lambda _seconds: None)
+
+    user_id = MODULE._create_user("https://api.dev.hypercli.com/api", "admin-key", "console@example.com")
+
+    assert user_id == "console-e2e-existing"

hypercli_sdk-2026.4.13/tests/test_bootstrap_dev_test_keys.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import importlib.util
+import sys
+import types
+from pathlib import Path
+
+import pytest
+
+try:
+    import requests as _requests
+except ModuleNotFoundError:
+    _requests = types.ModuleType("requests")
+
+    class _ReadTimeout(Exception):
+        pass
+
+    class _ConnectionError(Exception):
+        pass
+
+    _requests.exceptions = types.SimpleNamespace(
+        ReadTimeout=_ReadTimeout,
+        Timeout=_ReadTimeout,
+        ConnectionError=_ConnectionError,
+    )
+    _requests.request = lambda *_args, **_kwargs: None  # pragma: no cover
+
+sys.modules.setdefault("requests", _requests)
+
+
+SCRIPT_PATH = Path(__file__).resolve().parents[2] / ".github" / "scripts" / "bootstrap_dev_test_keys.py"
+SPEC = importlib.util.spec_from_file_location("bootstrap_dev_test_keys", SCRIPT_PATH)
+assert SPEC and SPEC.loader
+MODULE = importlib.util.module_from_spec(SPEC)
+sys.modules[SPEC.name] = MODULE
+SPEC.loader.exec_module(MODULE)
+
+
+class _FakeResponse:
+    def __init__(self, status_code: int, payload: dict | None = None, text: str = "") -> None:
+        self.status_code = status_code
+        self._payload = payload or {}
+        self.text = text
+
+    def json(self) -> dict:
+        return self._payload
+
+
+def test_request_retries_transient_status(monkeypatch: pytest.MonkeyPatch) -> None:
+    calls: list[int] = []
+
+    def fake_request(*_args, **_kwargs):
+        calls.append(1)
+        if len(calls) == 1:
+            return _FakeResponse(504, text="Gateway Timeout")
+        return _FakeResponse(200, {"ok": True})
+
+    monkeypatch.setattr(MODULE.requests, "request", fake_request)
+    monkeypatch.setattr(MODULE.time, "sleep", lambda _seconds: None)
+
+    response = MODULE._request("POST", "https://example.test/admin/users")
+
+    assert response.status_code == 200
+    assert len(calls) == 2
+
+
+def test_request_retries_timeout(monkeypatch: pytest.MonkeyPatch) -> None:
+    calls: list[int] = []
+
+    def fake_request(*_args, **_kwargs):
+        calls.append(1)
+        if len(calls) == 1:
+            raise _requests.exceptions.ReadTimeout("timed out")
+        return _FakeResponse(200, {"ok": True})
+
+    monkeypatch.setattr(MODULE.requests, "request", fake_request)
+    monkeypatch.setattr(MODULE.time, "sleep", lambda _seconds: None)
+
+    response = MODULE._request("GET", "https://example.test/admin/users")
+
+    assert response.status_code == 200
+    assert len(calls) == 2
+
+
+def test_create_or_get_hyperclaw_user_resolves_conflict(monkeypatch: pytest.MonkeyPatch) -> None:
+    responses = [
+        _FakeResponse(409, text="User already exists"),
+        _FakeResponse(200, {"items": [{"id": "user-123", "orchestra_user_id": "orch-123"}]}),
+    ]
+
+    def fake_request(*_args, **_kwargs):
+        return responses.pop(0)
+
+    monkeypatch.setattr(MODULE.requests, "request", fake_request)
+    monkeypatch.setattr(MODULE.time, "sleep", lambda _seconds: None)
+
+    payload = MODULE._create_or_get_hyperclaw_user(
+        agents_api_base="https://api.dev.hypercli.com/agents",
+        agents_admin_key="admin-key",
+        orchestra_user_id="orch-123",
+        email="sdk-int@example.com",
+    )
+
+    assert payload["id"] == "user-123"

{hypercli_sdk-2026.4.9 → hypercli_sdk-2026.4.13}/tests/test_claw.py

@@ -7,6 +7,9 @@ from unittest.mock import Mock, patch, MagicMock
 from hypercli import HyperCLI
 from hypercli.agent import (
     HyperAgent,
+    HyperAgentEntitlement,
+    HyperAgentEntitlements,
+    HyperAgentEntitlementsSummary,
     HyperAgentPlan,
     HyperAgentCurrentPlan,
     HyperAgentSubscription,
@@ -71,11 +74,40 @@ class TestHyperAgentDataclasses:
             {
                 "effective_plan_id": "large",
                 "current_subscription_id": "sub-1",
+                "current_entitlement_id": "sub-1",
                 "pooled_tpm_limit": 2000,
                 "pooled_rpm_limit": 20,
                 "pooled_tpd": 2000000,
+                "billing_reset_at": "2026-04-15T00:00:00Z",
                 "slot_inventory": {"large": {"granted": 2, "used": 1, "available": 1}},
                 "active_subscription_count": 1,
+                "active_entitlement_count": 1,
+                "entitlements": {
+                    "effective_plan_id": "large",
+                    "pooled_tpm_limit": 2000,
+                    "pooled_rpm_limit": 20,
+                    "pooled_tpd": 2000000,
+                    "billing_reset_at": "2026-04-15T00:00:00Z",
+                    "slot_inventory": {"large": {"granted": 2, "used": 1, "available": 1}},
+                    "active_entitlement_count": 1,
+                },
+                "entitlement_items": [
+                    {
+                        "id": "ent-1",
+                        "user_id": "user-1",
+                        "subscription_id": "sub-1",
+                        "plan_id": "large",
+                        "plan_name": "Large",
+                        "provider": "STRIPE",
+                        "status": "ACTIVE",
+                        "expires_at": "2026-04-15T00:00:00Z",
+                        "agent_tier": "large",
+                        "features": {"voice": True},
+                        "tags": ["customer=acme"],
+                        "active_agent_count": 1,
+                        "active_agent_ids": ["agent-1"],
+                    }
+                ],
                 "active_subscriptions": [
                     {
                         "id": "sub-1",
@@ -91,8 +123,15 @@ class TestHyperAgentDataclasses:
             }
         )
         assert summary.effective_plan_id == "large"
+        assert summary.current_entitlement_id == "sub-1"
         assert summary.active_subscription_count == 1
+        assert isinstance(summary.entitlements, HyperAgentEntitlements)
+        assert summary.entitlements.active_entitlement_count == 1
+        assert summary.billing_reset_at is not None
+        assert summary.entitlements.billing_reset_at is not None
         assert summary.active_subscriptions[0].plan_id == "large"
+        assert isinstance(summary.entitlement_items[0], HyperAgentEntitlement)
+        assert summary.entitlement_items[0].tags == ["customer=acme"]
 
 
 class TestHyperAgentClient:
@@ -151,6 +190,7 @@ class TestHyperAgentClient:
                     "provider": "STRIPE",
                     "status": "ACTIVE",
                     "quantity": 2,
+                    "current_period_end": "2026-04-15T00:00:00Z",
                 }
             ]
         }
@@ -161,6 +201,7 @@ class TestHyperAgentClient:
 
         assert len(subscriptions) == 1
         assert subscriptions[0].quantity == 2
+        assert subscriptions[0].expires_at is not None
         mock_http._session.get.assert_called_with(
             "https://api.hypercli.com/agents/subscriptions",
             headers={"Authorization": "Bearer sk-hyper-test"},
@@ -175,6 +216,24 @@ class TestHyperAgentClient:
             "pooled_tpd": 2000000,
             "slot_inventory": {"large": {"granted": 2, "used": 1, "available": 1}},
             "active_subscription_count": 1,
+            "active_entitlement_count": 1,
+            "entitlement_items": [
+                {
+                    "id": "ent-1",
+                    "user_id": "user-1",
+                    "subscription_id": "sub-1",
+                    "plan_id": "large",
+                    "plan_name": "Large",
+                    "provider": "STRIPE",
+                    "status": "ACTIVE",
+                    "expires_at": "2026-04-15T00:00:00Z",
+                    "agent_tier": "large",
+                    "features": {"voice": True},
+                    "tags": ["customer=acme"],
+                    "active_agent_count": 1,
+                    "active_agent_ids": ["agent-1"],
+                }
+            ],
             "active_subscriptions": [
                 {
                     "id": "sub-1",
@@ -195,10 +254,157 @@ class TestHyperAgentClient:
 
         assert summary.current_subscription_id == "sub-1"
         assert summary.slot_inventory["large"]["available"] == 1
+        assert summary.entitlement_items[0].plan_id == "large"
         mock_http._session.get.assert_called_with(
             "https://api.hypercli.com/agents/subscriptions/summary",
             headers={"Authorization": "Bearer sk-hyper-test"},
         )
+
+    def test_entitlements(self, mock_http):
+        mock_http._session.get.return_value.json.return_value = {
+            "effective_plan_id": "large",
+            "current_subscription_id": "sub-1",
+            "current_entitlement_id": "sub-1",
+            "pooled_tpm_limit": 2000,
+            "pooled_rpm_limit": 20,
+            "pooled_tpd": 2000000,
+            "billing_reset_at": "2026-04-15T00:00:00Z",
+            "slot_inventory": {"large": {"granted": 2, "used": 1, "available": 1}},
+            "active_subscription_count": 1,
+            "active_entitlement_count": 1,
+            "entitlements": {
+                "effective_plan_id": "large",
+                "pooled_tpm_limit": 2000,
+                "pooled_rpm_limit": 20,
+                "pooled_tpd": 2000000,
+                "billing_reset_at": "2026-04-15T00:00:00Z",
+                "slot_inventory": {"large": {"granted": 2, "used": 1, "available": 1}},
+                "active_entitlement_count": 1,
+            },
+            "entitlement_items": [
+                {
+                    "id": "ent-1",
+                    "user_id": "user-1",
+                    "plan_id": "large",
+                    "plan_name": "Large",
+                    "provider": "X402",
+                    "status": "ACTIVE",
+                    "expires_at": "2026-04-20T00:00:00Z",
+                    "agent_tier": "large",
+                    "features": {"voice": True},
+                    "tags": ["customer=acme"],
+                    "active_agent_count": 0,
+                    "active_agent_ids": [],
+                }
+            ],
+            "active_subscriptions": [],
+            "subscriptions": [],
+            "user": {"id": "user-1", "team_id": "team-1"},
+        }
+        mock_http._session.get.return_value.raise_for_status = Mock()
+
+        agent = HyperAgent(mock_http, agent_api_key="sk-hyper-test", agents_api_base_url="https://api.hypercli.com/agents")
+        summary = agent.entitlements()
+
+        assert isinstance(summary, HyperAgentEntitlementsSummary)
+        assert summary.billing_reset_at is not None
+        assert summary.entitlements.slot_inventory["large"]["available"] == 1
+        assert summary.entitlement_items[0].provider == "X402"
+        mock_http._session.get.assert_called_with(
+            "https://api.hypercli.com/agents/entitlements",
+            headers={"Authorization": "Bearer sk-hyper-test"},
+        )
+
+    def test_entitlement_instances(self, mock_http):
+        mock_http._session.get.return_value.json.return_value = {
+            "items": [
+                {
+                    "id": "ent-1",
+                    "user_id": "user-1",
+                    "subscription_id": None,
+                    "plan_id": "large",
+                    "plan_name": "Large",
+                    "provider": "X402",
+                    "status": "ACTIVE",
+                    "expires_at": "2026-04-20T00:00:00Z",
+                    "agent_tier": "large",
+                    "features": {"voice": True},
+                    "tags": ["customer=acme"],
+                    "active_agent_count": 0,
+                    "active_agent_ids": [],
+                }
+            ]
+        }
+        mock_http._session.get.return_value.raise_for_status = Mock()
+
+        agent = HyperAgent(mock_http, agent_api_key="sk-hyper-test", agents_api_base_url="https://api.hypercli.com/agents")
+        entitlements = agent.entitlement_instances()
+
+        assert len(entitlements) == 1
+        assert entitlements[0].plan_id == "large"
+        assert entitlements[0].tags == ["customer=acme"]
+        mock_http._session.get.assert_called_with(
+            "https://api.hypercli.com/agents/entitlements/instances",
+            headers={"Authorization": "Bearer sk-hyper-test"},
+        )
+
+    def test_cancel_subscription(self, mock_http):
+        mock_http._session.post.return_value.json.return_value = {
+            "ok": True,
+            "message": "Subscription will be cancelled at the end of the current billing period",
+            "subscription": {
+                "id": "sub-1",
+                "user_id": "user-1",
+                "plan_id": "large",
+                "plan_name": "Large",
+                "provider": "STRIPE",
+                "status": "ACTIVE",
+                "cancel_at_period_end": True,
+                "can_cancel": True,
+            },
+        }
+        mock_http._session.post.return_value.raise_for_status = Mock()
+
+        agent = HyperAgent(mock_http, agent_api_key="sk-hyper-test", agents_api_base_url="https://api.hypercli.com/agents")
+        result = agent.cancel_subscription("sub-1")
+
+        assert result.ok is True
+        assert result.subscription is not None
+        assert result.subscription.cancel_at_period_end is True
+        mock_http._session.post.assert_called_with(
+            "https://api.hypercli.com/agents/subscriptions/sub-1/update",
+            headers={"Authorization": "Bearer sk-hyper-test"},
+            json={"bundle": {}},
+        )
+
+    def test_update_subscription(self, mock_http):
+        mock_http._session.post.return_value.json.return_value = {
+            "ok": True,
+            "message": "Subscription upgraded immediately",
+            "subscription": {
+                "id": "sub-1",
+                "user_id": "user-1",
+                "plan_id": "large",
+                "plan_name": "Large",
+                "provider": "STRIPE",
+                "status": "ACTIVE",
+                "cancel_at_period_end": False,
+                "can_cancel": True,
+            },
+        }
+        mock_http._session.post.return_value.raise_for_status = Mock()
+
+        agent = HyperAgent(mock_http, agent_api_key="sk-hyper-test", agents_api_base_url="https://api.hypercli.com/agents")
+        result = agent.update_subscription("sub-1", {"large": 1})
+
+        assert result.ok is True
+        assert result.subscription is not None
+        assert result.subscription.plan_id == "large"
+        mock_http._session.post.assert_called_with(
+            "https://api.hypercli.com/agents/subscriptions/sub-1/update",
+            headers={"Authorization": "Bearer sk-hyper-test"},
+            json={"bundle": {"large": 1}},
+        )
     
     def test_openai_client_creation(self, mock_http):
         """Test that OpenAI client is created with correct config."""

{hypercli_sdk-2026.4.9 → hypercli_sdk-2026.4.13}/tests/test_gateway.py

@@ -4,8 +4,9 @@ import asyncio
 import json
 
 import pytest
+import httpx
 
-from hypercli.gateway import GatewayClient, normalize_gateway_chat_message
+from hypercli.openclaw.gateway import GatewayClient, normalize_gateway_chat_message
 
 
 class MockConnection:
@@ -49,7 +50,7 @@ async def test_connect_auto_approves_pairing_and_reconnects(monkeypatch: pytest.
     async def fake_approve(self: GatewayClient, request_id: str) -> None:
         approvals.append((self.deployment_id or "", request_id))
 
-    monkeypatch.setattr("hypercli.gateway.websockets.connect", fake_connect)
+    monkeypatch.setattr("hypercli.openclaw.gateway.websockets.connect", fake_connect)
     monkeypatch.setattr(GatewayClient, "_approve_pairing_request", fake_approve)
 
     client = GatewayClient(
@@ -118,6 +119,55 @@ async def test_connect_auto_approves_pairing_and_reconnects(monkeypatch: pytest.
     assert client.is_connected is True
     assert client.pending_pairing is None
 
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_approve_pairing_request_uses_direct_local_pairing_api(monkeypatch: pytest.MonkeyPatch) -> None:
+    captured: dict = {}
+
+    class FakeResponse:
+        status_code = 200
+
+        def json(self) -> dict:
+            return {"exit_code": 0, "stdout": "approved", "stderr": ""}
+
+    class FakeAsyncClient:
+        def __init__(self, *args, **kwargs) -> None:
+            pass
+
+        async def __aenter__(self):
+            return self
+
+        async def __aexit__(self, exc_type, exc, tb) -> None:
+            return None
+
+        async def post(self, url: str, *, headers: dict, json: dict):
+            captured["url"] = url
+            captured["headers"] = headers
+            captured["json"] = json
+            return FakeResponse()
+
+    monkeypatch.setattr(httpx, "AsyncClient", FakeAsyncClient)
+
+    client = GatewayClient(
+        url="wss://openclaw-agent.example",
+        gateway_token="gw-token",
+        deployment_id="deployment-123",
+        api_key="agent-key",
+        api_base="https://api.dev.hypercli.com/agents",
+        auto_approve_pairing=True,
+    )
+
+    await client._approve_pairing_request("pairing-req-1")
+
+    assert captured["url"] == "https://api.dev.hypercli.com/agents/deployments/deployment-123/exec"
+    assert captured["json"]["timeout"] == 30
+    command = captured["json"]["command"]
+    assert command.startswith("openclaw devices approve ")
+    assert " --json" in command
+    assert "pairing-req-1" in command
+
 
 def test_set_gateway_token_normalizes_blank_values() -> None:
     client = GatewayClient(url="wss://openclaw-agent.example", gateway_token="gw-token-1")

{hypercli_sdk-2026.4.9 → hypercli_sdk-2026.4.13}/tests/test_gateway_retry.py

@@ -6,7 +6,7 @@ import json
 import pytest
 from websockets.exceptions import InvalidStatus
 
-from hypercli.gateway import GatewayClient
+from hypercli.openclaw.gateway import GatewayClient
 
 
 class _FakeResponse:
@@ -55,7 +55,7 @@ async def test_connect_retries_transient_503(monkeypatch: pytest.MonkeyPatch) ->
             raise InvalidStatus(_FakeResponse(503))
         return connection
 
-    monkeypatch.setattr("hypercli.gateway.websockets.connect", fake_connect)
+    monkeypatch.setattr("hypercli.openclaw.gateway.websockets.connect", fake_connect)
 
     client = GatewayClient(
         url="wss://openclaw-agent.example",
@@ -93,3 +93,5 @@ async def test_connect_retries_transient_503(monkeypatch: pytest.MonkeyPatch) ->
 
     assert attempts == 2
     assert client.is_connected is True
+
+    await client.close()