hypercli-sdk 2026.4.13.post4__tar.gz → 2026.4.18__tar.gz

{hypercli_sdk-2026.4.13.post4 → hypercli_sdk-2026.4.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypercli-sdk
-Version: 2026.4.13.post4
+Version: 2026.4.18
 Summary: Python SDK for HyperCLI - GPU orchestration and HyperAgent API
 Project-URL: Homepage, https://hypercli.com
 Project-URL: Documentation, https://docs.hypercli.com
@@ -140,11 +140,14 @@ OpenClaw uses the generic deployment launch surface. `registry_url`, `registry_a
 agent = client.deployments.create_openclaw(
     name="docs-demo",
     start=True,
+    heartbeat={"every": "0m"},  # disable upstream OpenClaw heartbeat runs
     registry_url="git.nedos.co",
     registry_auth={"username": "ci", "password": "token"},
 )
 ```
 
+`heartbeat` maps directly to upstream OpenClaw config at `config.agents.defaults.heartbeat`. Omit it to keep upstream defaults, or pass values such as `heartbeat={"every": "1h", "target": "last"}`.
+
 ## Error Handling
 
 ```python

{hypercli_sdk-2026.4.13.post4 → hypercli_sdk-2026.4.18}/README.md

@@ -109,11 +109,14 @@ OpenClaw uses the generic deployment launch surface. `registry_url`, `registry_a
 agent = client.deployments.create_openclaw(
     name="docs-demo",
     start=True,
+    heartbeat={"every": "0m"},  # disable upstream OpenClaw heartbeat runs
     registry_url="git.nedos.co",
     registry_auth={"username": "ci", "password": "token"},
 )
 ```
 
+`heartbeat` maps directly to upstream OpenClaw config at `config.agents.defaults.heartbeat`. Omit it to keep upstream defaults, or pass values such as `heartbeat={"every": "1h", "target": "last"}`.
+
 ## Error Handling
 
 ```python

{hypercli_sdk-2026.4.13.post4 → hypercli_sdk-2026.4.18}/hypercli/__init__.py

@@ -78,7 +78,7 @@ from .gateway import (
     extract_gateway_chat_tool_calls,
     normalize_gateway_chat_message,
 )
-__version__ = "2026.4.13.post4"
+__version__ = "2026.4.18"
 __all__ = [
     "HyperCLI",
     "configure",

{hypercli_sdk-2026.4.13.post4 → hypercli_sdk-2026.4.18}/hypercli/agent.py

@@ -221,6 +221,36 @@ class HyperAgentEntitlements:
         )
 
 
+@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
+
+    @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
+            ),
+        )
+
+
 @dataclass
 class HyperAgentSubscriptionSummary:
     """Effective entitlement summary for an authenticated HyperClaw user."""
@@ -236,7 +266,6 @@ class HyperAgentSubscriptionSummary:
     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]
@@ -257,7 +286,6 @@ class HyperAgentSubscriptionSummary:
             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 {},
@@ -267,21 +295,6 @@ class HyperAgentSubscriptionSummary:
 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."""
@@ -888,102 +901,13 @@ class HyperAgent:
         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:
+    def cancel_subscription(self, subscription_id: str) -> Dict[str, Any]:
         response = self._http._session.post(
-            f"{self._control_base_url}/subscriptions/{subscription_id}/update",
+            f"{self._control_base_url}/subscriptions/{subscription_id}/cancel",
             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 usage_summary(self) -> HyperAgentUsageSummary:
-        return HyperAgentUsageSummary.from_dict(self._control_get("/usage"))
-
-    def usage_history(self, days: int = 7) -> HyperAgentUsageHistory:
-        return HyperAgentUsageHistory.from_dict(self._control_get("/usage/history", params={"days": days}))
-
-    def key_usage(self, days: int = 7) -> HyperAgentKeyUsage:
-        return HyperAgentKeyUsage.from_dict(self._control_get("/usage/keys", params={"days": days}))
-
-    def agent_types(self) -> HyperAgentTypeCatalog:
-        return HyperAgentTypeCatalog.from_dict(self._control_get("/types"))
-
-    def billing_info(self) -> HyperAgentBillingInfo:
-        return HyperAgentBillingInfo.from_dict(self._control_get("/billing/info").get("company_billing", {}))
-
-    def billing_profile(self) -> HyperAgentBillingProfileResponse:
-        return HyperAgentBillingProfileResponse.from_dict(self._control_get("/billing/profile"))
-
-    def update_billing_profile(self, profile: HyperAgentBillingProfileFields) -> HyperAgentBillingProfileResponse:
-        return HyperAgentBillingProfileResponse.from_dict(
-            self._control_put("/billing/profile", payload=profile.to_dict())
-        )
-
-    def payments(
-        self,
-        *,
-        limit: int | None = None,
-        provider: str | None = None,
-        status: str | None = None,
-    ) -> HyperAgentPaymentsResponse:
-        params: dict[str, Any] = {}
-        if limit is not None:
-            params["limit"] = limit
-        if provider:
-            params["provider"] = provider
-        if status:
-            params["status"] = status
-        return HyperAgentPaymentsResponse.from_dict(self._control_get("/billing/payments", params=params or None))
-
-    def payment(self, payment_id: str) -> HyperAgentPayment:
-        return HyperAgentPayment.from_dict(self._control_get(f"/billing/payments/{payment_id}"))
-
-    def create_stripe_checkout(
-        self,
-        *,
-        bundle: dict[str, int] | None = None,
-        quantity: int | None = None,
-        success_url: str | None = None,
-        cancel_url: str | None = None,
-        plan_id: str | None = None,
-    ) -> HyperAgentStripeCheckoutResponse:
-        payload: dict[str, Any] = {}
-        if bundle is not None:
-            payload["bundle"] = dict(bundle)
-        if quantity is not None:
-            payload["quantity"] = quantity
-        if success_url is not None:
-            payload["success_url"] = success_url
-        if cancel_url is not None:
-            payload["cancel_url"] = cancel_url
-        path = f"/stripe/{plan_id}" if plan_id else "/stripe/checkout"
-        return HyperAgentStripeCheckoutResponse.from_dict(self._control_post(path, payload=payload))
-
-    def create_x402_checkout(
-        self,
-        *,
-        bundle: dict[str, int] | None = None,
-        quantity: int | None = None,
-    ) -> HyperAgentX402CheckoutResponse:
-        payload: dict[str, Any] = {}
-        if bundle is not None:
-            payload["bundle"] = dict(bundle)
-        if quantity is not None:
-            payload["quantity"] = quantity
-        return HyperAgentX402CheckoutResponse.from_dict(self._control_post("/x402/checkout", payload=payload))
+        return response.json()
 
     def discovery_health(self) -> Dict[str, Any]:
         response = self._http._session.get(f"{self._api_base_without_v1()}/discovery/health")

{hypercli_sdk-2026.4.13.post4 → hypercli_sdk-2026.4.18}/hypercli/agents.py

@@ -191,14 +191,23 @@ def _build_agent_launch(
     registry_url: str | None = None,
     registry_auth: dict | None = None,
     gateway_token: str | None = None,
+    heartbeat: dict | None = None,
 ) -> tuple[dict, str]:
-    prepared_config = dict(config or {})
+    prepared_config = copy.deepcopy(config or {})
     nested_launch_keys = sorted(LAUNCH_CONFIG_KEYS.intersection(prepared_config.keys()))
     if nested_launch_keys:
         raise ValueError(
             "Launch settings must be top-level fields, not nested under config: "
             + ", ".join(nested_launch_keys)
         )
+    if heartbeat:
+        agents_cfg = dict(prepared_config.get("agents") or {})
+        defaults_cfg = dict(agents_cfg.get("defaults") or {})
+        heartbeat_cfg = dict(defaults_cfg.get("heartbeat") or {})
+        heartbeat_cfg.update(dict(heartbeat))
+        defaults_cfg["heartbeat"] = heartbeat_cfg
+        agents_cfg["defaults"] = defaults_cfg
+        prepared_config["agents"] = agents_cfg
     env_map = dict(env or {})
     if env:
         env_map.update(env)
@@ -1015,6 +1024,7 @@ class Deployments:
         registry_url: str = None,
         registry_auth: dict = None,
         gateway_token: str = None,
+        heartbeat: dict = None,
         meta_ui: dict = None,
         dry_run: bool = False,
         start: bool = True,
@@ -1045,6 +1055,7 @@ class Deployments:
             registry_url=registry_url,
             registry_auth=registry_auth,
             gateway_token=gateway_token,
+            heartbeat=heartbeat,
         )
         body: dict = {**launch_payload, "start": start}
         if dry_run:
@@ -1083,6 +1094,7 @@ class Deployments:
         registry_url: str = None,
         registry_auth: dict = None,
         gateway_token: str = None,
+        heartbeat: dict = None,
         meta_ui: dict = None,
         dry_run: bool = False,
         start: bool = True,
@@ -1110,6 +1122,7 @@ class Deployments:
             registry_url=registry_url,
             registry_auth=registry_auth,
             gateway_token=gateway_token,
+            heartbeat=heartbeat,
             meta_ui=meta_ui,
             dry_run=dry_run,
             start=start,
@@ -1185,6 +1198,7 @@ class Deployments:
         registry_url: str = None,
         registry_auth: dict = None,
         gateway_token: str = None,
+        heartbeat: dict = None,
         dry_run: bool = False,
     ) -> Agent:
         """Start a previously stopped agent.
@@ -1208,6 +1222,7 @@ class Deployments:
             registry_url=registry_url,
             registry_auth=registry_auth,
             gateway_token=gateway_token,
+            heartbeat=heartbeat,
         )
         body: dict[str, Any] = dict(launch_payload)
         if dry_run:
@@ -1236,6 +1251,7 @@ class Deployments:
         registry_url: str = None,
         registry_auth: dict = None,
         gateway_token: str = None,
+        heartbeat: dict = None,
         dry_run: bool = False,
         openclaw_routes: dict | None = None,
         openclaw_route_options: dict | None = None,
@@ -1259,6 +1275,7 @@ class Deployments:
             registry_url=registry_url,
             registry_auth=registry_auth,
             gateway_token=gateway_token,
+            heartbeat=heartbeat,
             dry_run=dry_run,
         )
 

{hypercli_sdk-2026.4.13.post4 → hypercli_sdk-2026.4.18}/hypercli/voice.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 """Voice API client."""
+import os
 from pathlib import Path
 from typing import TYPE_CHECKING
 import base64
@@ -17,9 +18,22 @@ def _encode_reference_audio(ref_audio: bytes | str | Path) -> str:
     return base64.b64encode(audio_bytes).decode()
 
 
+def _default_voice_timeout() -> float:
+    raw_value = os.environ.get("HYPER_VOICE_TIMEOUT_SECONDS", "300").strip()
+    try:
+        return float(raw_value)
+    except ValueError:
+        return 300.0
+
+
+def _resolve_voice_timeout(timeout: float | None) -> float:
+    if timeout is not None:
+        return float(timeout)
+    return _default_voice_timeout()
+
+
 class VoiceAPI:
     """Voice capability API wrapper."""
-
     DEFAULT_TIMEOUT = 300.0
 
     def __init__(self, http: "HTTPClient"):
@@ -32,7 +46,7 @@ class VoiceAPI:
         voice: str = "Chelsie",
         language: str = "auto",
         response_format: str = "mp3",
-        timeout: float = DEFAULT_TIMEOUT,
+        timeout: float | None = None,
     ) -> bytes:
         return self._http.post_bytes(
             "/agents/voice/tts",
@@ -42,7 +56,7 @@ class VoiceAPI:
                 "language": language,
                 "response_format": response_format,
             },
-            timeout=timeout,
+            timeout=_resolve_voice_timeout(timeout),
         )
 
     def clone(
@@ -53,7 +67,7 @@ class VoiceAPI:
         language: str = "auto",
         x_vector_only: bool = True,
         response_format: str = "mp3",
-        timeout: float = DEFAULT_TIMEOUT,
+        timeout: float | None = None,
     ) -> bytes:
         return self._http.post_bytes(
             "/agents/voice/clone",
@@ -64,7 +78,7 @@ class VoiceAPI:
                 "x_vector_only": x_vector_only,
                 "response_format": response_format,
             },
-            timeout=timeout,
+            timeout=_resolve_voice_timeout(timeout),
         )
 
     def design(
@@ -74,7 +88,7 @@ class VoiceAPI:
         description: str,
         language: str = "auto",
         response_format: str = "mp3",
-        timeout: float = DEFAULT_TIMEOUT,
+        timeout: float | None = None,
     ) -> bytes:
         return self._http.post_bytes(
             "/agents/voice/design",
@@ -84,5 +98,5 @@ class VoiceAPI:
                 "language": language,
                 "response_format": response_format,
             },
-            timeout=timeout,
+            timeout=_resolve_voice_timeout(timeout),
         )

{hypercli_sdk-2026.4.13.post4 → hypercli_sdk-2026.4.18}/pyproject.toml

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

{hypercli_sdk-2026.4.13.post4 → hypercli_sdk-2026.4.18}/tests/integration/test_agents.py

@@ -12,32 +12,48 @@ def _create_agent_with_available_tier(client: HyperCLI, name: str, tags: list[st
     budget = client.deployments.budget()
     slots = (budget or {}).get("slots") or {}
 
-    tier = next((candidate for candidate in ("large", "medium", "small") if int((slots.get(candidate) or {}).get("available") or 0) > 0), None)
-    if not tier:
+    tiers = [
+        candidate
+        for candidate in ("large", "medium", "small")
+        if int((slots.get(candidate) or {}).get("available") or 0) > 0
+    ]
+    if not tiers:
         raise AssertionError("No available entitlement slots for integration agent tests")
 
-    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 agent_id:
-            try:
-                client.deployments.delete(agent_id)
-            except APIError:
-                pass
-        if exc.status_code == 429:
-            raise AssertionError(
-                f"Budget reported '{tier}' available but dry-run start was rejected for slot exhaustion"
-            ) from exc
-        raise
+    last_error: Exception | None = None
+    for tier in tiers:
+        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 agent_id:
+                try:
+                    client.deployments.delete(agent_id)
+                except APIError:
+                    pass
+            if exc.status_code == 429:
+                last_error = AssertionError(
+                    f"Budget reported '{tier}' available but dry-run start was rejected for slot exhaustion"
+                )
+                continue
+            if exc.status_code == 503 and "No connected clusters available for tags" in str(exc.detail):
+                last_error = AssertionError(
+                    f"Tier '{tier}' has entitlement capacity but no connected clusters are advertising that tag"
+                )
+                continue
+            raise
+
+    if last_error:
+        raise last_error
+    raise AssertionError("Failed to create an integration agent with any available tier")
 
 
 def test_list_agents_requires_agent_key(client, test_agent_api_key: str):

{hypercli_sdk-2026.4.13.post4 → hypercli_sdk-2026.4.18}/tests/test_agents.py

@@ -416,6 +416,27 @@ def test_build_agent_launch_includes_command_and_entrypoint():
     assert launch["routes"] == {"web": {"port": 80, "prefix": ""}}
 
 
+def test_build_agent_launch_merges_heartbeat_defaults():
+    launch, _gateway_token = _build_agent_launch(
+        {"agents": {"defaults": {"model": "openai/gpt-5.4", "heartbeat": {"target": "last"}}}},
+        heartbeat={"every": "0m", "includeSystemPromptSection": False},
+        gateway_token="gw-token",
+    )
+
+    assert launch["config"] == {
+        "agents": {
+            "defaults": {
+                "model": "openai/gpt-5.4",
+                "heartbeat": {
+                    "target": "last",
+                    "every": "0m",
+                    "includeSystemPromptSection": False,
+                },
+            }
+        }
+    }
+
+
 def test_build_openclaw_routes_defaults():
     assert build_openclaw_routes() == {
         "openclaw": {"port": 18789, "auth": False, "prefix": ""},
@@ -485,6 +506,35 @@ def test_create_openclaw_respects_explicit_empty_routes(agents_client):
         assert posted_json["image"] == DEFAULT_OPENCLAW_IMAGE
         assert posted_json["routes"] == {}
 
+
+def test_create_openclaw_includes_heartbeat_when_requested(agents_client):
+    with patch("httpx.Client") as mock_client_class, patch("hypercli.agents.secrets.token_hex", return_value="gw-token-123"):
+        mock_client = MagicMock()
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "id": "agent-123",
+            "user_id": "user-456",
+            "pod_id": "pod-789",
+            "pod_name": "test-pod",
+            "state": "starting",
+        }
+        mock_client.post.return_value = mock_response
+        mock_client.__enter__.return_value = mock_client
+        mock_client.__exit__.return_value = False
+        mock_client_class.return_value = mock_client
+
+        agents_client.create_openclaw(
+            name="test-agent",
+            heartbeat={"every": "0m", "includeSystemPromptSection": False},
+        )
+
+        posted_json = mock_client.post.call_args[1]["json"]
+        assert posted_json["config"]["agents"]["defaults"]["heartbeat"] == {
+            "every": "0m",
+            "includeSystemPromptSection": False,
+        }
+
 @pytest.fixture
 def mock_http():
     http = Mock(spec=HTTPClient)
@@ -970,7 +1020,7 @@ def test_agents_create_scoped_key(agents_client):
             "key_id": "key-123",
             "name": "agent-client",
             "api_key": "hyper_api_scoped",
-            "tags": ["agent=agent-123"],
+            "tags": ["agent:agent-123"],
         }
         mock_client.post.return_value = mock_response
         mock_client.__enter__.return_value = mock_client

{hypercli_sdk-2026.4.13.post4 → hypercli_sdk-2026.4.18}/tests/test_claw.py

@@ -7,7 +7,6 @@ from unittest.mock import Mock, patch, MagicMock
 from hypercli import HyperCLI
 from hypercli.agent import (
     HyperAgent,
-    HyperAgentEntitlement,
     HyperAgentEntitlements,
     HyperAgentEntitlementsSummary,
     HyperAgentPlan,
@@ -97,27 +96,9 @@ class TestHyperAgentDataclasses:
                     "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",
@@ -137,8 +118,6 @@ class TestHyperAgentDataclasses:
         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"]
@@ -279,7 +258,6 @@ class TestHyperAgentClient:
             "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,
@@ -288,26 +266,9 @@ class TestHyperAgentClient:
                 "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"},
@@ -318,242 +279,27 @@ class TestHyperAgentClient:
         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"
+        assert result["ok"] is True
         mock_http._session.post.assert_called_with(
-            "https://api.hypercli.com/agents/subscriptions/sub-1/update",
+            "https://api.hypercli.com/agents/subscriptions/sub-1/cancel",
             headers={"Authorization": "Bearer sk-hyper-test"},
-            json={"bundle": {"large": 1}},
         )
-
-    def test_usage_endpoints(self, mock_http):
-        mock_http._session.get.side_effect = [
-            Mock(json=Mock(return_value={
-                "total_tokens": 100,
-                "prompt_tokens": 60,
-                "completion_tokens": 40,
-                "request_count": 5,
-                "active_keys": 2,
-                "current_tpm": 1000,
-                "current_rpm": 10,
-                "period": "30d",
-            }), raise_for_status=Mock()),
-            Mock(json=Mock(return_value={
-                "history": [{"date": "2026-04-13", "total_tokens": 100, "prompt_tokens": 60, "completion_tokens": 40, "requests": 5}],
-                "days": 7,
-            }), raise_for_status=Mock()),
-            Mock(json=Mock(return_value={
-                "keys": [{"key_hash": "key-1", "name": "Primary", "total_tokens": 100, "prompt_tokens": 60, "completion_tokens": 40, "requests": 5}],
-                "days": 7,
-            }), 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.usage_summary()
-        history = agent.usage_history()
-        keys = agent.key_usage()
-
-        assert isinstance(summary, HyperAgentUsageSummary)
-        assert summary.total_tokens == 100
-        assert isinstance(history, HyperAgentUsageHistory)
-        assert history.history[0].date == "2026-04-13"
-        assert isinstance(keys, HyperAgentKeyUsage)
-        assert keys.keys[0].key_hash == "key-1"
-
-    def test_types_and_billing_endpoints(self, mock_http):
-        mock_http._session.get.side_effect = [
-            Mock(json=Mock(return_value={
-                "types": [{"id": "medium", "name": "Medium", "cpu": 1, "memory": 2, "cpu_limit": 1, "memory_limit": 2}],
-                "plans": [{"id": "2aiu", "name": "2 AIU", "price": 20, "agents": 1, "agent_type": "medium", "highlighted": True}],
-            }), raise_for_status=Mock()),
-            Mock(json=Mock(return_value={
-                "company_billing": {"address": ["HyperCLI"], "email": "support@hypercli.com"},
-                "profile": None,
-            }), raise_for_status=Mock()),
-            Mock(json=Mock(return_value={
-                "company_billing": {"address": ["HyperCLI"], "email": "support@hypercli.com"},
-                "profile": {"billing_name": "Test User"},
-            }), raise_for_status=Mock()),
-        ]
-        mock_http._session.put.return_value.json.return_value = {
-            "company_billing": {"address": ["HyperCLI"], "email": "support@hypercli.com"},
-            "profile": {"billing_name": "Test User"},
-            "synced_stripe_customer_ids": ["cus_123"],
-        }
-        mock_http._session.put.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")
-        catalog = agent.agent_types()
-        info = agent.billing_info()
-        profile = agent.billing_profile()
-        updated = agent.update_billing_profile(HyperAgentBillingProfileFields(billing_name="Test User"))
-
-        assert isinstance(catalog, HyperAgentTypeCatalog)
-        assert catalog.types[0].id == "medium"
-        assert isinstance(info, HyperAgentBillingInfo)
-        assert info.email == "support@hypercli.com"
-        assert isinstance(profile, HyperAgentBillingProfileResponse)
-        assert profile.profile is not None
-        assert profile.profile.billing_name == "Test User"
-        assert updated.synced_stripe_customer_ids == ["cus_123"]
-
-    def test_payments_and_checkout_endpoints(self, mock_http):
-        mock_http._session.get.side_effect = [
-            Mock(json=Mock(return_value={
-                "items": [{
-                    "id": "pay_123",
-                    "user_id": "user-1",
-                    "subscription_id": None,
-                    "entitlement_id": None,
-                    "provider": "STRIPE",
-                    "status": "SUCCEEDED",
-                    "amount": "2000",
-                    "currency": "usd",
-                    "external_payment_id": "pi_123",
-                    "created_at": "2026-04-13T00:00:00Z",
-                    "updated_at": "2026-04-13T00:00:00Z",
-                    "user": {"id": "user-1", "email": "user@example.com", "wallet_address": None, "team_id": "team-1", "plan_id": "2aiu"},
-                    "subscription": None,
-                    "entitlement": None,
-                }]
-            }), raise_for_status=Mock()),
-            Mock(json=Mock(return_value={
-                "id": "pay_123",
-                "user_id": "user-1",
-                "subscription_id": None,
-                "entitlement_id": None,
-                "provider": "STRIPE",
-                "status": "SUCCEEDED",
-                "amount": "2000",
-                "currency": "usd",
-                "external_payment_id": "pi_123",
-                "created_at": "2026-04-13T00:00:00Z",
-                "updated_at": "2026-04-13T00:00:00Z",
-                "user": {"id": "user-1", "email": "user@example.com", "wallet_address": None, "team_id": "team-1", "plan_id": "2aiu"},
-                "subscription": None,
-                "entitlement": None,
-            }), raise_for_status=Mock()),
-        ]
-        mock_http._session.post.side_effect = [
-            Mock(json=Mock(return_value={"checkout_url": "https://checkout.stripe.test/session"}), raise_for_status=Mock()),
-            Mock(json=Mock(return_value={
-                "ok": True,
-                "key": "sk-x402",
-                "plan_id": "2aiu",
-                "quantity": 1,
-                "bundle": {"medium": 1},
-                "amount_paid": "20.000000",
-                "duration_days": 30,
-                "expires_at": "2026-05-13T00:00:00Z",
-                "tpm_limit": 1000,
-                "rpm_limit": 10,
-            }), raise_for_status=Mock()),
-        ]
-
-        agent = HyperAgent(mock_http, agent_api_key="sk-hyper-test", agents_api_base_url="https://api.hypercli.com/agents")
-        payments = agent.payments(limit=10, provider="stripe", status="succeeded")
-        payment = agent.payment("pay_123")
-        stripe = agent.create_stripe_checkout(bundle={"medium": 1})
-        x402 = agent.create_x402_checkout(bundle={"medium": 1})
-
-        assert isinstance(payments, HyperAgentPaymentsResponse)
-        assert payments.items[0].id == "pay_123"
-        assert payment.external_payment_id == "pi_123"
-        assert isinstance(stripe, HyperAgentStripeCheckoutResponse)
-        assert stripe.checkout_url == "https://checkout.stripe.test/session"
-        assert isinstance(x402, HyperAgentX402CheckoutResponse)
-        assert x402.plan_id == "2aiu"
     
     def test_openai_client_creation(self, mock_http):
         """Test that OpenAI client is created with correct config."""

{hypercli_sdk-2026.4.13.post4 → hypercli_sdk-2026.4.18}/tests/test_voice.py

@@ -70,3 +70,14 @@ def test_voice_design_posts_description():
             VoiceAPI.DEFAULT_TIMEOUT,
         )
     ]
+
+
+def test_voice_timeout_uses_env_default(monkeypatch):
+    monkeypatch.setenv("HYPER_VOICE_TIMEOUT_SECONDS", "720")
+
+    http = DummyVoiceHTTP()
+    voice = VoiceAPI(http)
+
+    voice.tts("hello")
+
+    assert http.calls[0][2] == 720.0