hypercli-sdk 2026.4.6__tar.gz → 2026.4.7__tar.gz

{hypercli_sdk-2026.4.6 → hypercli_sdk-2026.4.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypercli-sdk
-Version: 2026.4.6
+Version: 2026.4.7
 Summary: Python SDK for HyperCLI - GPU orchestration and HyperAgent API
 Project-URL: Homepage, https://hypercli.com
 Project-URL: Documentation, https://docs.hypercli.com

{hypercli_sdk-2026.4.6 → hypercli_sdk-2026.4.7}/hypercli/__init__.py

@@ -38,7 +38,14 @@ from .job import BaseJob, ComfyUIJob, GradioJob, apply_params, apply_graph_modes
 from .logs import LogStream, stream_logs, fetch_logs
 from .agents import Deployments, Agent, OpenClawAgent, ExecResult, build_openclaw_routes
 from .shell import ShellSession, shell_connect
-from .agent import HyperAgent, HyperAgentPlan, HyperAgentModel
+from .agent import (
+    HyperAgent,
+    HyperAgentPlan,
+    HyperAgentCurrentPlan,
+    HyperAgentSubscription,
+    HyperAgentSubscriptionSummary,
+    HyperAgentModel,
+)
 from .gateway import (
     GatewayClient,
     GatewayError,
@@ -50,7 +57,7 @@ from .gateway import (
     extract_gateway_chat_tool_calls,
     normalize_gateway_chat_message,
 )
-__version__ = "2026.4.6"
+__version__ = "2026.4.7"
 __all__ = [
     "HyperCLI",
     "configure",
@@ -130,6 +137,9 @@ __all__ = [
     # HyperAgent
     "HyperAgent",
     "HyperAgentPlan",
+    "HyperAgentCurrentPlan",
+    "HyperAgentSubscription",
+    "HyperAgentSubscriptionSummary",
     "HyperAgentModel",
     # OpenClaw Gateway
     "GatewayClient",

hypercli_sdk-2026.4.7/hypercli/agent.py

@@ -0,0 +1,386 @@
+"""
+HyperAgent API client
+
+Provides access to the HyperClaw inference API for AI agents.
+Uses the official OpenAI Python client for chat completions.
+"""
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Union
+from urllib.parse import urlsplit
+
+from .config import get_agents_api_base_url
+from .http import HTTPClient
+
+try:
+    from openai import OpenAI
+
+    OPENAI_AVAILABLE = True
+except ImportError:
+    OpenAI = None
+    OPENAI_AVAILABLE = False
+
+
+@dataclass
+class HyperAgentPlan:
+    """HyperAgent subscription plan."""
+
+    id: str
+    name: str
+    price_usd: float
+    tpm_limit: int
+    rpm_limit: int
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "HyperAgentPlan":
+        price = data.get("price_usd", data.get("price", 0))
+        return cls(
+            id=data["id"],
+            name=data.get("name", data["id"]),
+            price_usd=float(price or 0),
+            tpm_limit=int(data.get("tpm_limit", 0)),
+            rpm_limit=int(data.get("rpm_limit", 0)),
+        )
+
+
+@dataclass
+class HyperAgentCurrentPlan:
+    """Effective current plan snapshot for an authenticated HyperClaw user."""
+
+    id: str
+    name: str
+    price: float | str
+    aiu: int | None = None
+    agents: int | None = None
+    tpm_limit: int = 0
+    rpm_limit: int = 0
+    expires_at: datetime | None = None
+    cancel_at_period_end: bool = False
+    provider: str | None = None
+    seconds_remaining: int | None = None
+    pooled_tpd: int = 0
+    slot_inventory: dict[str, Any] | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "HyperAgentCurrentPlan":
+        expires_at = data.get("expires_at")
+        if expires_at:
+            expires_at = datetime.fromisoformat(str(expires_at).replace("Z", "+00:00"))
+        return cls(
+            id=data["id"],
+            name=data.get("name", data["id"]),
+            price=data.get("price", 0),
+            aiu=data.get("aiu"),
+            agents=data.get("agents"),
+            tpm_limit=int(data.get("tpm_limit", 0) or 0),
+            rpm_limit=int(data.get("rpm_limit", 0) or 0),
+            expires_at=expires_at,
+            cancel_at_period_end=bool(data.get("cancel_at_period_end", False)),
+            provider=data.get("provider"),
+            seconds_remaining=data.get("seconds_remaining"),
+            pooled_tpd=int(data.get("pooled_tpd", 0) or 0),
+            slot_inventory=data.get("slot_inventory") or None,
+        )
+
+
+@dataclass
+class HyperAgentSubscription:
+    """A purchased HyperClaw entitlement/subscription instance."""
+
+    id: str
+    user_id: str
+    plan_id: str
+    plan_name: str
+    provider: str
+    status: str
+    quantity: int = 1
+    expires_at: datetime | None = None
+    updated_at: datetime | None = None
+    stripe_subscription_id: str | None = None
+    cancel_at_period_end: bool = False
+    can_cancel: bool = False
+    is_current: bool = False
+    meta: dict[str, Any] | None = None
+    plan_tpm_limit: int = 0
+    plan_rpm_limit: int = 0
+    plan_tpd: int = 0
+    plan_agent_tier: str | None = None
+    slot_grants: dict[str, int] | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "HyperAgentSubscription":
+        expires_at = data.get("expires_at")
+        updated_at = data.get("updated_at")
+        return cls(
+            id=data["id"],
+            user_id=data.get("user_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", ""),
+            quantity=int(data.get("quantity", 1) or 1),
+            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,
+            stripe_subscription_id=data.get("stripe_subscription_id"),
+            cancel_at_period_end=bool(data.get("cancel_at_period_end", False)),
+            can_cancel=bool(data.get("can_cancel", False)),
+            is_current=bool(data.get("is_current", False)),
+            meta=data.get("meta") or None,
+            plan_tpm_limit=int(data.get("plan_tpm_limit", 0) or 0),
+            plan_rpm_limit=int(data.get("plan_rpm_limit", 0) or 0),
+            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,
+        )
+
+
+@dataclass
+class HyperAgentSubscriptionSummary:
+    """Effective entitlement summary for an authenticated HyperClaw user."""
+
+    effective_plan_id: str
+    current_subscription_id: str | None
+    pooled_tpm_limit: int
+    pooled_rpm_limit: int
+    pooled_tpd: int
+    slot_inventory: dict[str, Any]
+    active_subscription_count: int
+    active_subscriptions: list[HyperAgentSubscription]
+    subscriptions: list[HyperAgentSubscription]
+    user: dict[str, Any]
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "HyperAgentSubscriptionSummary":
+        return cls(
+            effective_plan_id=data.get("effective_plan_id", ""),
+            current_subscription_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 {},
+            active_subscription_count=int(data.get("active_subscription_count", 0) or 0),
+            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 {},
+        )
+
+
+@dataclass
+class HyperAgentModel:
+    """Available model on HyperAgent."""
+
+    id: str
+    name: str
+    context_length: int
+    supports_vision: bool = False
+    supports_function_calling: bool = False
+    supports_tool_choice: bool = False
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "HyperAgentModel":
+        caps = data.get("capabilities", {})
+        return cls(
+            id=data["id"],
+            name=data.get("name", data["id"]),
+            context_length=data.get("context_length", 0),
+            supports_vision=caps.get("supports_vision", False),
+            supports_function_calling=caps.get("supports_function_calling", False),
+            supports_tool_choice=caps.get("supports_tool_choice", False),
+        )
+
+
+class HyperAgent:
+    """
+    HyperAgent API client.
+
+    Provides access to HyperClaw inference endpoints using the OpenAI Python
+    client.
+
+    Usage:
+        from hypercli import HyperCLI
+
+        client = HyperCLI(agent_api_key="sk-...")
+
+        openai = client.agent.openai
+        response = openai.chat.completions.create(
+            model="kimi-k2.5",
+            messages=[{"role": "user", "content": "Hello!"}],
+        )
+
+        response = client.agent.chat(
+            model="kimi-k2.5",
+            messages=[{"role": "user", "content": "Hello!"}],
+        )
+    """
+
+    AGENT_API_BASE = "https://api.hypercli.com/v1"
+    DEV_API_BASE = "https://api.dev.hypercli.com/v1"
+
+    def __init__(
+        self,
+        http: HTTPClient,
+        agent_api_key: str = None,
+        dev: bool = False,
+        agents_api_base_url: str | None = None,
+    ):
+        self._http = http
+        self._api_key = agent_api_key or http.api_key
+        self._dev = dev
+        self._base_url = self._resolve_base_url(agents_api_base_url, dev)
+        self._control_base_url = self._resolve_control_base_url(getattr(http, "base_url", None), agents_api_base_url, dev)
+        self._openai = None
+
+    @classmethod
+    def _resolve_base_url(cls, agents_api_base_url: str | None, dev: bool) -> str:
+        raw = (agents_api_base_url or "").rstrip("/")
+        if not raw:
+            fallback = get_agents_api_base_url(dev).rstrip("/")
+            return cls._resolve_base_url(fallback, dev)
+        parsed = urlsplit(raw if "://" in raw else f"https://{raw}")
+        host = parsed.netloc.lower()
+        if host in {"api.hypercli.com", "api.hyperclaw.app", "api.agents.hypercli.com"}:
+            return "https://api.agents.hypercli.com/v1"
+        if host in {"api.dev.hypercli.com", "api.dev.hyperclaw.app", "dev-api.hyperclaw.app", "api.agents.dev.hypercli.com"}:
+            return "https://api.agents.dev.hypercli.com/v1"
+        if raw.endswith("/api"):
+            return f"{raw[:-4]}/v1"
+        if raw.endswith("/agents"):
+            return f"{raw[:-7]}/v1"
+        if raw:
+            return f"{raw}/v1"
+        return cls.DEV_API_BASE if dev else cls.AGENT_API_BASE
+
+    @classmethod
+    def _resolve_control_base_url(
+        cls,
+        product_api_base_url: str | None,
+        agents_api_base_url: str | None,
+        dev: bool,
+    ) -> str:
+        raw_agents = (agents_api_base_url or "").rstrip("/")
+        if not raw_agents:
+            fallback = get_agents_api_base_url(dev).rstrip("/")
+            return cls._resolve_control_base_url(None, fallback, dev)
+        parsed = urlsplit(raw_agents if "://" in raw_agents else f"https://{raw_agents}")
+        scheme = parsed.scheme or "https"
+        normalized_path = parsed.path.rstrip("/")
+        host = parsed.netloc.lower()
+        if normalized_path.endswith("/agents"):
+            return f"{scheme}://{parsed.netloc}{normalized_path}"
+        if host in {"api.hypercli.com", "api.hyperclaw.app", "api.agents.hypercli.com"}:
+            return "https://api.hypercli.com/agents"
+        if host in {"api.dev.hypercli.com", "api.dev.hyperclaw.app", "dev-api.hyperclaw.app", "api.agents.dev.hypercli.com"}:
+            return "https://api.dev.hypercli.com/agents"
+        return f"{scheme}://{parsed.netloc}/agents"
+
+    @property
+    def openai(self) -> "OpenAI":
+        if not OPENAI_AVAILABLE:
+            raise ImportError(
+                "OpenAI package required for chat. Install with: pip install openai"
+            )
+
+        if self._openai is None:
+            self._openai = OpenAI(
+                api_key=self._api_key,
+                base_url=self._base_url,
+            )
+        return self._openai
+
+    def chat(
+        self,
+        model: str,
+        messages: List[Dict],
+        temperature: float = None,
+        max_tokens: int = None,
+        tools: List[Dict] = None,
+        tool_choice: Union[str, Dict] = None,
+        stream: bool = False,
+        **kwargs,
+    ):
+        params = {
+            "model": model,
+            "messages": messages,
+            **kwargs,
+        }
+
+        if temperature is not None:
+            params["temperature"] = temperature
+        if max_tokens is not None:
+            params["max_tokens"] = max_tokens
+        if tools:
+            params["tools"] = tools
+        if tool_choice:
+            params["tool_choice"] = tool_choice
+        if stream:
+            params["stream"] = stream
+
+        return self.openai.chat.completions.create(**params)
+
+    def models(self) -> List[HyperAgentModel]:
+        response = self.openai.models.list()
+        return [
+            HyperAgentModel.from_dict(
+                {
+                    "id": model.id,
+                    "name": getattr(model, "name", model.id),
+                    "context_length": getattr(model, "context_length", 0),
+                    "capabilities": getattr(model, "capabilities", {}),
+                }
+            )
+            for model in response.data
+        ]
+
+    def _api_base_without_v1(self) -> str:
+        return self._base_url.replace("/v1", "")
+
+    def plans(self) -> List[HyperAgentPlan]:
+        response = self._http._session.get(
+            f"{self._control_base_url}/plans",
+            headers={"Authorization": f"Bearer {self._api_key}"},
+        )
+        response.raise_for_status()
+        data = response.json()
+        return [HyperAgentPlan.from_dict(plan) for plan in data.get("plans", [])]
+
+    def current_plan(self) -> HyperAgentCurrentPlan:
+        response = self._http._session.get(
+            f"{self._control_base_url}/plans/current",
+            headers={"Authorization": f"Bearer {self._api_key}"},
+        )
+        response.raise_for_status()
+        return HyperAgentCurrentPlan.from_dict(response.json())
+
+    def subscriptions(self) -> list[HyperAgentSubscription]:
+        response = self._http._session.get(
+            f"{self._control_base_url}/subscriptions",
+            headers={"Authorization": f"Bearer {self._api_key}"},
+        )
+        response.raise_for_status()
+        data = response.json()
+        return [HyperAgentSubscription.from_dict(item) for item in data.get("items", [])]
+
+    def subscription_summary(self) -> HyperAgentSubscriptionSummary:
+        response = self._http._session.get(
+            f"{self._control_base_url}/subscriptions/summary",
+            headers={"Authorization": f"Bearer {self._api_key}"},
+        )
+        response.raise_for_status()
+        return HyperAgentSubscriptionSummary.from_dict(response.json())
+
+    def discovery_health(self) -> Dict[str, Any]:
+        response = self._http._session.get(f"{self._api_base_without_v1()}/discovery/health")
+        response.raise_for_status()
+        return response.json()
+
+    def discovery_config(self, api_key: str = None) -> Dict[str, Any]:
+        headers = {}
+        if api_key:
+            headers["X-API-KEY"] = api_key
+
+        response = self._http._session.get(
+            f"{self._api_base_without_v1()}/discovery/config",
+            headers=headers,
+        )
+        response.raise_for_status()
+        return response.json()

{hypercli_sdk-2026.4.6 → hypercli_sdk-2026.4.7}/hypercli/agents.py

@@ -258,6 +258,7 @@ def _deep_merge_config(base: dict[str, Any], patch: dict[str, Any]) -> dict[str,
 
 
 def _agent_kwargs_from_dict(data: dict) -> dict[str, Any]:
+    meta = data.get("meta") if isinstance(data.get("meta"), dict) else {}
     return {
         "id": data.get("id", ""),
         "user_id": data.get("user_id", ""),
@@ -277,6 +278,7 @@ def _agent_kwargs_from_dict(data: dict) -> dict[str, Any]:
         "created_at": _parse_dt(data.get("created_at")),
         "updated_at": _parse_dt(data.get("updated_at")),
         "launch_config": data.get("launch_config"),
+        "meta_ui": copy.deepcopy(meta.get("ui")) if isinstance(meta.get("ui"), dict) else None,
         "routes": data.get("routes") or {},
         "command": data.get("command") or [],
         "entrypoint": data.get("entrypoint") or [],
@@ -306,6 +308,7 @@ class Agent:
     created_at: Optional[datetime] = None
     updated_at: Optional[datetime] = None
     launch_config: Optional[dict] = None
+    meta_ui: Optional[dict] = None
     routes: dict[str, dict] = field(default_factory=dict)
     command: list[str] = field(default_factory=list)
     entrypoint: list[str] = field(default_factory=list)
@@ -992,6 +995,7 @@ class Deployments:
         registry_url: str = None,
         registry_auth: dict = None,
         gateway_token: str = None,
+        meta_ui: dict = None,
         dry_run: bool = False,
         start: bool = True,
     ) -> Agent:
@@ -1035,6 +1039,8 @@ class Deployments:
             body["cpu"] = cpu
         if memory is not None:
             body["memory"] = memory
+        if meta_ui:
+            body["meta"] = {"ui": copy.deepcopy(meta_ui)}
         if tags:
             body["tags"] = list(tags)
         data = self._post(AGENTS_API_PREFIX, json=body)
@@ -1065,6 +1071,7 @@ class Deployments:
         registry_url: str = None,
         registry_auth: dict = None,
         gateway_token: str = None,
+        meta_ui: dict = None,
         dry_run: bool = False,
         start: bool = True,
         openclaw_routes: dict | None = None,
@@ -1092,6 +1099,7 @@ class Deployments:
             registry_url=registry_url,
             registry_auth=registry_auth,
             gateway_token=gateway_token,
+            meta_ui=meta_ui,
             dry_run=dry_run,
             start=start,
         )

{hypercli_sdk-2026.4.6 → hypercli_sdk-2026.4.7}/hypercli/gateway.py

@@ -783,6 +783,9 @@ class GatewayClient:
     def pending_pairing(self) -> GatewayPairingState | None:
         return self._pending_pairing
 
+    def set_gateway_token(self, token: str | None) -> None:
+        self.gateway_token = token.strip() if isinstance(token, str) and token.strip() else None
+
     def _storage_scope(self) -> str:
         return self.deployment_id or self.url
 

{hypercli_sdk-2026.4.6 → hypercli_sdk-2026.4.7}/pyproject.toml

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

{hypercli_sdk-2026.4.6 → hypercli_sdk-2026.4.7}/tests/integration/test_agents.py

@@ -8,6 +8,40 @@ from hypercli import HyperCLI
 from hypercli.http import APIError
 
 
+def _create_agent_with_available_tier(client: HyperCLI, name: str, tags: list[str]) -> tuple[str, str]:
+    last_error: APIError | None = None
+    for tier in ("large", "medium", "small"):
+        agent_id: str | None = None
+        try:
+            agent = client.deployments.create(
+                name=name,
+                size=tier,
+                start=False,
+                tags=tags,
+            )
+            agent_id = agent.id
+            client.deployments.start_openclaw(agent.id, dry_run=True)
+            return agent.id, tier
+        except APIError as exc:
+            if exc.status_code == 429:
+                if agent_id:
+                    try:
+                        client.deployments.delete(agent_id)
+                    except APIError:
+                        pass
+                last_error = exc
+                continue
+            if agent_id:
+                try:
+                    client.deployments.delete(agent_id)
+                except APIError:
+                    pass
+            raise
+    if last_error is not None:
+        raise last_error
+    raise AssertionError("No available entitlement slots for integration agent tests")
+
+
 def test_list_agents_requires_agent_key(client, test_agent_api_key: str):
     if not test_agent_api_key:
         pytest.skip(
@@ -24,18 +58,18 @@ def test_exact_agent_child_key_is_scoped_to_one_agent(client, test_api_base: str
             "TEST_AGENT_API_KEY not set; the deployments and agent APIs do not accept the account-level TEST_API_KEY"
         )
 
-    agent_a = client.deployments.create(
+    agent_a_id, agent_a_tier = _create_agent_with_available_tier(
+        client,
         name=f"sdk-scope-{uuid.uuid4().hex[:8]}",
-        size="small",
-        start=False,
         tags=["team=dev", "suite=sdk-integration"],
     )
-    agent_b = client.deployments.create(
+    agent_b_id, _agent_b_tier = _create_agent_with_available_tier(
+        client,
         name=f"sdk-scope-{uuid.uuid4().hex[:8]}",
-        size="small",
-        start=False,
         tags=["team=ops", "suite=sdk-integration"],
     )
+    agent_a = client.deployments.get(agent_a_id)
+    agent_b = client.deployments.get(agent_b_id)
 
     try:
         child = client.deployments.create_scoped_key(agent_a.id, name="sdk-scoped-child")
@@ -64,7 +98,7 @@ def test_exact_agent_child_key_is_scoped_to_one_agent(client, test_api_base: str
         with pytest.raises(APIError) as create_exc:
             scoped.deployments.create(
                 name=f"sdk-scope-{uuid.uuid4().hex[:8]}",
-                size="small",
+                size=agent_a_tier,
                 start=False,
             )
         assert create_exc.value.status_code == 403

{hypercli_sdk-2026.4.6 → hypercli_sdk-2026.4.7}/tests/test_agents.py

@@ -40,6 +40,36 @@ def test_agent_from_dict_minimal():
     assert agent.ports == []
 
 
+def test_agent_from_dict_hydrates_only_meta_ui():
+    agent = Agent.from_dict(
+        {
+            "id": "agent-123",
+            "user_id": "user-456",
+            "pod_id": "pod-789",
+            "pod_name": "test-pod",
+            "state": "pending",
+            "meta": {
+                "ui": {
+                    "avatar": {
+                        "image": "data:image/png;base64,abc",
+                        "icon_index": 4,
+                    }
+                },
+                "internal": {
+                    "ignored": True,
+                },
+            },
+        }
+    )
+
+    assert agent.meta_ui == {
+        "avatar": {
+            "image": "data:image/png;base64,abc",
+            "icon_index": 4,
+        }
+    }
+
+
 def test_agent_urls_and_running_state():
     agent = Agent(
         id="agent-123",
@@ -492,6 +522,12 @@ def test_agents_create_returns_openclaw_agent(agents_client):
             size="medium",
             cpu=4,
             memory=16,
+            meta_ui={
+                "avatar": {
+                    "image": "data:image/png;base64,xyz",
+                    "icon_index": 7,
+                }
+            },
             env={"FOO": "bar"},
             ports=[{"port": 18789, "auth": False}],
             command=["nginx", "-g", "daemon off;"],
@@ -507,6 +543,14 @@ def test_agents_create_returns_openclaw_agent(agents_client):
             "FOO": "bar",
             "OPENCLAW_GATEWAY_TOKEN": "gw-token-123",
         }
+        assert posted_json["meta"] == {
+            "ui": {
+                "avatar": {
+                    "image": "data:image/png;base64,xyz",
+                    "icon_index": 7,
+                }
+            }
+        }
         assert posted_json["command"] == ["nginx", "-g", "daemon off;"]
         assert posted_json["entrypoint"] == ["/docker-entrypoint.sh"]
         assert posted_json["image"] == "ghcr.io/hypercli/hypercli-openclaw:test"
@@ -515,6 +559,7 @@ def test_agents_create_returns_openclaw_agent(agents_client):
         assert isinstance(agent, OpenClawAgent)
         assert agent.gateway_token == "gw-token-123"
         assert agent.gateway_url == "wss://openclaw-test.hypercli.com"
+        assert agent.meta_ui is None
         assert agent._deployments is agents_client
 
 

{hypercli_sdk-2026.4.6 → hypercli_sdk-2026.4.7}/tests/test_claw.py

@@ -5,7 +5,14 @@ import pytest
 import os
 from unittest.mock import Mock, patch, MagicMock
 from hypercli import HyperCLI
-from hypercli.agent import HyperAgent, HyperAgentPlan, HyperAgentModel
+from hypercli.agent import (
+    HyperAgent,
+    HyperAgentPlan,
+    HyperAgentCurrentPlan,
+    HyperAgentSubscription,
+    HyperAgentSubscriptionSummary,
+    HyperAgentModel,
+)
 
 
 class TestHyperAgentDataclasses:
@@ -40,6 +47,53 @@ class TestHyperAgentDataclasses:
         assert model.supports_vision is True
         assert model.supports_function_calling is True
 
+    def test_current_plan_from_dict(self):
+        current = HyperAgentCurrentPlan.from_dict(
+            {
+                "id": "large",
+                "name": "Large",
+                "price": 99,
+                "tpm_limit": 1000,
+                "rpm_limit": 10,
+                "expires_at": "2026-04-07T10:00:00Z",
+                "cancel_at_period_end": True,
+                "pooled_tpd": 1000000,
+                "slot_inventory": {"large": {"granted": 1, "used": 0, "available": 1}},
+            }
+        )
+        assert current.id == "large"
+        assert current.cancel_at_period_end is True
+        assert current.expires_at is not None
+        assert current.slot_inventory["large"]["granted"] == 1
+
+    def test_subscription_summary_from_dict(self):
+        summary = HyperAgentSubscriptionSummary.from_dict(
+            {
+                "effective_plan_id": "large",
+                "current_subscription_id": "sub-1",
+                "pooled_tpm_limit": 2000,
+                "pooled_rpm_limit": 20,
+                "pooled_tpd": 2000000,
+                "slot_inventory": {"large": {"granted": 2, "used": 1, "available": 1}},
+                "active_subscription_count": 1,
+                "active_subscriptions": [
+                    {
+                        "id": "sub-1",
+                        "user_id": "user-1",
+                        "plan_id": "large",
+                        "plan_name": "Large",
+                        "provider": "STRIPE",
+                        "status": "ACTIVE",
+                    }
+                ],
+                "subscriptions": [],
+                "user": {"id": "user-1", "team_id": "team-1"},
+            }
+        )
+        assert summary.effective_plan_id == "large"
+        assert summary.active_subscription_count == 1
+        assert summary.active_subscriptions[0].plan_id == "large"
+
 
 class TestHyperAgentClient:
     """Tests for HyperAgent client methods."""
@@ -66,6 +120,85 @@ class TestHyperAgentClient:
         assert result["status"] == "ok"
         assert result["hosts_total"] == 1
         mock_http._session.get.assert_called_once()
+
+    def test_current_plan(self, mock_http):
+        mock_http._session.get.return_value.json.return_value = {
+            "id": "large",
+            "name": "Large",
+            "price": 99,
+            "tpm_limit": 1000,
+            "rpm_limit": 10,
+        }
+        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")
+        current = agent.current_plan()
+
+        assert current.id == "large"
+        mock_http._session.get.assert_called_with(
+            "https://api.hypercli.com/agents/plans/current",
+            headers={"Authorization": "Bearer sk-hyper-test"},
+        )
+
+    def test_subscriptions(self, mock_http):
+        mock_http._session.get.return_value.json.return_value = {
+            "items": [
+                {
+                    "id": "sub-1",
+                    "user_id": "user-1",
+                    "plan_id": "large",
+                    "plan_name": "Large",
+                    "provider": "STRIPE",
+                    "status": "ACTIVE",
+                    "quantity": 2,
+                }
+            ]
+        }
+        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")
+        subscriptions = agent.subscriptions()
+
+        assert len(subscriptions) == 1
+        assert subscriptions[0].quantity == 2
+        mock_http._session.get.assert_called_with(
+            "https://api.hypercli.com/agents/subscriptions",
+            headers={"Authorization": "Bearer sk-hyper-test"},
+        )
+
+    def test_subscription_summary(self, mock_http):
+        mock_http._session.get.return_value.json.return_value = {
+            "effective_plan_id": "large",
+            "current_subscription_id": "sub-1",
+            "pooled_tpm_limit": 2000,
+            "pooled_rpm_limit": 20,
+            "pooled_tpd": 2000000,
+            "slot_inventory": {"large": {"granted": 2, "used": 1, "available": 1}},
+            "active_subscription_count": 1,
+            "active_subscriptions": [
+                {
+                    "id": "sub-1",
+                    "user_id": "user-1",
+                    "plan_id": "large",
+                    "plan_name": "Large",
+                    "provider": "STRIPE",
+                    "status": "ACTIVE",
+                }
+            ],
+            "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.subscription_summary()
+
+        assert summary.current_subscription_id == "sub-1"
+        assert summary.slot_inventory["large"]["available"] == 1
+        mock_http._session.get.assert_called_with(
+            "https://api.hypercli.com/agents/subscriptions/summary",
+            headers={"Authorization": "Bearer sk-hyper-test"},
+        )
     
     def test_openai_client_creation(self, mock_http):
         """Test that OpenAI client is created with correct config."""

{hypercli_sdk-2026.4.6 → hypercli_sdk-2026.4.7}/tests/test_gateway.py

@@ -119,6 +119,16 @@ async def test_connect_auto_approves_pairing_and_reconnects(monkeypatch: pytest.
     assert client.pending_pairing is None
 
 
+def test_set_gateway_token_normalizes_blank_values() -> None:
+    client = GatewayClient(url="wss://openclaw-agent.example", gateway_token="gw-token-1")
+
+    client.set_gateway_token("  gw-token-2  ")
+    assert client.gateway_token == "gw-token-2"
+
+    client.set_gateway_token("   ")
+    assert client.gateway_token is None
+
+
 @pytest.mark.asyncio
 async def test_chat_send_accepts_chat_content_and_done_events() -> None:
     client = GatewayClient(url="wss://openclaw-agent.example")

hypercli_sdk-2026.4.6/hypercli/agent.py

@@ -1,215 +0,0 @@
-"""
-HyperAgent API client
-
-Provides access to the HyperClaw inference API for AI agents.
-Uses the official OpenAI Python client for chat completions.
-"""
-from dataclasses import dataclass
-from datetime import datetime
-from typing import Any, Dict, List, Optional, Union
-from urllib.parse import urlsplit
-
-from .config import get_agents_api_base_url
-from .http import HTTPClient
-
-try:
-    from openai import OpenAI
-
-    OPENAI_AVAILABLE = True
-except ImportError:
-    OpenAI = None
-    OPENAI_AVAILABLE = False
-
-
-@dataclass
-class HyperAgentPlan:
-    """HyperAgent subscription plan."""
-
-    id: str
-    name: str
-    price_usd: float
-    tpm_limit: int
-    rpm_limit: int
-
-    @classmethod
-    def from_dict(cls, data: dict) -> "HyperAgentPlan":
-        price = data.get("price_usd", data.get("price", 0))
-        return cls(
-            id=data["id"],
-            name=data.get("name", data["id"]),
-            price_usd=float(price or 0),
-            tpm_limit=int(data.get("tpm_limit", 0)),
-            rpm_limit=int(data.get("rpm_limit", 0)),
-        )
-
-
-@dataclass
-class HyperAgentModel:
-    """Available model on HyperAgent."""
-
-    id: str
-    name: str
-    context_length: int
-    supports_vision: bool = False
-    supports_function_calling: bool = False
-    supports_tool_choice: bool = False
-
-    @classmethod
-    def from_dict(cls, data: dict) -> "HyperAgentModel":
-        caps = data.get("capabilities", {})
-        return cls(
-            id=data["id"],
-            name=data.get("name", data["id"]),
-            context_length=data.get("context_length", 0),
-            supports_vision=caps.get("supports_vision", False),
-            supports_function_calling=caps.get("supports_function_calling", False),
-            supports_tool_choice=caps.get("supports_tool_choice", False),
-        )
-
-
-class HyperAgent:
-    """
-    HyperAgent API client.
-
-    Provides access to HyperClaw inference endpoints using the OpenAI Python
-    client.
-
-    Usage:
-        from hypercli import HyperCLI
-
-        client = HyperCLI(agent_api_key="sk-...")
-
-        openai = client.agent.openai
-        response = openai.chat.completions.create(
-            model="kimi-k2.5",
-            messages=[{"role": "user", "content": "Hello!"}],
-        )
-
-        response = client.agent.chat(
-            model="kimi-k2.5",
-            messages=[{"role": "user", "content": "Hello!"}],
-        )
-    """
-
-    AGENT_API_BASE = "https://api.hypercli.com/v1"
-    DEV_API_BASE = "https://api.dev.hypercli.com/v1"
-
-    def __init__(
-        self,
-        http: HTTPClient,
-        agent_api_key: str = None,
-        dev: bool = False,
-        agents_api_base_url: str | None = None,
-    ):
-        self._http = http
-        self._api_key = agent_api_key or http.api_key
-        self._dev = dev
-        self._base_url = self._resolve_base_url(agents_api_base_url, dev)
-        self._openai = None
-
-    @classmethod
-    def _resolve_base_url(cls, agents_api_base_url: str | None, dev: bool) -> str:
-        raw = (agents_api_base_url or "").rstrip("/")
-        if not raw:
-            fallback = get_agents_api_base_url(dev).rstrip("/")
-            return cls._resolve_base_url(fallback, dev)
-        parsed = urlsplit(raw if "://" in raw else f"https://{raw}")
-        host = parsed.netloc.lower()
-        if host in {"api.hypercli.com", "api.hyperclaw.app", "api.agents.hypercli.com"}:
-            return "https://api.agents.hypercli.com/v1"
-        if host in {"api.dev.hypercli.com", "api.dev.hyperclaw.app", "dev-api.hyperclaw.app", "api.agents.dev.hypercli.com"}:
-            return "https://api.agents.dev.hypercli.com/v1"
-        if raw.endswith("/api"):
-            return f"{raw[:-4]}/v1"
-        if raw.endswith("/agents"):
-            return f"{raw[:-7]}/v1"
-        if raw:
-            return f"{raw}/v1"
-        return cls.DEV_API_BASE if dev else cls.AGENT_API_BASE
-
-    @property
-    def openai(self) -> "OpenAI":
-        if not OPENAI_AVAILABLE:
-            raise ImportError(
-                "OpenAI package required for chat. Install with: pip install openai"
-            )
-
-        if self._openai is None:
-            self._openai = OpenAI(
-                api_key=self._api_key,
-                base_url=self._base_url,
-            )
-        return self._openai
-
-    def chat(
-        self,
-        model: str,
-        messages: List[Dict],
-        temperature: float = None,
-        max_tokens: int = None,
-        tools: List[Dict] = None,
-        tool_choice: Union[str, Dict] = None,
-        stream: bool = False,
-        **kwargs,
-    ):
-        params = {
-            "model": model,
-            "messages": messages,
-            **kwargs,
-        }
-
-        if temperature is not None:
-            params["temperature"] = temperature
-        if max_tokens is not None:
-            params["max_tokens"] = max_tokens
-        if tools:
-            params["tools"] = tools
-        if tool_choice:
-            params["tool_choice"] = tool_choice
-        if stream:
-            params["stream"] = stream
-
-        return self.openai.chat.completions.create(**params)
-
-    def models(self) -> List[HyperAgentModel]:
-        response = self.openai.models.list()
-        return [
-            HyperAgentModel.from_dict(
-                {
-                    "id": model.id,
-                    "name": getattr(model, "name", model.id),
-                    "context_length": getattr(model, "context_length", 0),
-                    "capabilities": getattr(model, "capabilities", {}),
-                }
-            )
-            for model in response.data
-        ]
-
-    def _api_base_without_v1(self) -> str:
-        return self._base_url.replace("/v1", "")
-
-    def plans(self) -> List[HyperAgentPlan]:
-        response = self._http._session.get(
-            f"{self._api_base_without_v1()}/api/plans",
-            headers={"Authorization": f"Bearer {self._api_key}"},
-        )
-        response.raise_for_status()
-        data = response.json()
-        return [HyperAgentPlan.from_dict(plan) for plan in data.get("plans", [])]
-
-    def discovery_health(self) -> Dict[str, Any]:
-        response = self._http._session.get(f"{self._api_base_without_v1()}/discovery/health")
-        response.raise_for_status()
-        return response.json()
-
-    def discovery_config(self, api_key: str = None) -> Dict[str, Any]:
-        headers = {}
-        if api_key:
-            headers["X-API-KEY"] = api_key
-
-        response = self._http._session.get(
-            f"{self._api_base_without_v1()}/discovery/config",
-            headers=headers,
-        )
-        response.raise_for_status()
-        return response.json()