hypercli-sdk 2026.4.18__tar.gz → 2026.4.20__tar.gz

{hypercli_sdk-2026.4.18 → hypercli_sdk-2026.4.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypercli-sdk
-Version: 2026.4.18
+Version: 2026.4.20
 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.18 → hypercli_sdk-2026.4.20}/hypercli/__init__.py

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

{hypercli_sdk-2026.4.18 → hypercli_sdk-2026.4.20}/hypercli/agent.py

@@ -7,7 +7,7 @@ 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 urllib.parse import quote, urlsplit
 
 from .config import get_agents_api_base_url
 from .http import HTTPClient
@@ -266,6 +266,7 @@ 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]
@@ -286,6 +287,7 @@ 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 {},
@@ -909,6 +911,54 @@ class HyperAgent:
         response.raise_for_status()
         return response.json()
 
+    def purchase_via_x402(
+        self,
+        plan_id: str,
+        *,
+        quantity: int | None = None,
+        bundle: dict[str, int] | None = None,
+    ) -> HyperAgentX402CheckoutResponse:
+        payload: dict[str, Any] = {}
+        if quantity is not None:
+            payload["quantity"] = int(quantity)
+        if bundle is not None:
+            payload["bundle"] = {str(k): int(v) for k, v in bundle.items()}
+        response = self._http._session.post(
+            f"{self._control_base_url}/x402/{quote(str(plan_id), safe='')}",
+            headers={"Authorization": f"Bearer {self._api_key}"},
+            json=payload,
+        )
+        response.raise_for_status()
+        return HyperAgentX402CheckoutResponse.from_dict(response.json())
+
+    def purchase_bundle_via_x402(
+        self,
+        *,
+        quantity: int | None = None,
+        bundle: dict[str, int] | None = None,
+    ) -> HyperAgentX402CheckoutResponse:
+        payload: dict[str, Any] = {}
+        if quantity is not None:
+            payload["quantity"] = int(quantity)
+        if bundle is not None:
+            payload["bundle"] = {str(k): int(v) for k, v in bundle.items()}
+        response = self._http._session.post(
+            f"{self._control_base_url}/x402/_bundle",
+            headers={"Authorization": f"Bearer {self._api_key}"},
+            json=payload,
+        )
+        response.raise_for_status()
+        return HyperAgentX402CheckoutResponse.from_dict(response.json())
+
+    def create_x402_checkout(
+        self,
+        *,
+        quantity: int | None = None,
+        bundle: dict[str, int] | None = None,
+    ) -> HyperAgentX402CheckoutResponse:
+        """Backward-compatible bundle x402 checkout shim."""
+        return self.purchase_bundle_via_x402(quantity=quantity, bundle=bundle)
+
     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.18 → hypercli_sdk-2026.4.20}/hypercli/agents.py

@@ -1350,6 +1350,21 @@ class Deployments:
         payload = {"name": name} if name is not None else {}
         return self._post(f"{AGENTS_API_PREFIX}/{agent_id}/keys", json=payload or None)
 
+    def purchase_entitlement_from_balance(
+        self,
+        plan_id: str,
+        *,
+        duration: int,
+        tags: list[str] | None = None,
+    ) -> dict:
+        payload: dict[str, Any] = {"duration": int(duration)}
+        if tags is not None:
+            payload["tags"] = list(tags)
+        return self._post(f"/billing/balance/{quote(str(plan_id), safe='')}", json=payload)
+
+    def redeem_grant_code(self, code: str) -> dict:
+        return self._post("/billing/grants/redeem", json={"code": str(code)})
+
     def logs_token(self, agent_id: str) -> dict:
         """Mint a short-lived JWT token for backend log streaming."""
         return self._post(f"{AGENTS_API_PREFIX}/{agent_id}/logs/token")

{hypercli_sdk-2026.4.18 → hypercli_sdk-2026.4.20}/pyproject.toml

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

{hypercli_sdk-2026.4.18 → hypercli_sdk-2026.4.20}/tests/test_agents.py

@@ -1034,6 +1034,48 @@ def test_agents_create_scoped_key(agents_client):
         assert mock_client.post.call_args[1]["json"] == {"name": "agent-client"}
 
 
+def test_agents_purchase_entitlement_from_balance(agents_client):
+    with patch("httpx.Client") as mock_client_class:
+        mock_client = MagicMock()
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "grant": {"id": "grant-1", "type": "BALANCE", "duration": 3600},
+            "entitlement": {"id": "ent-1", "plan_id": "1aiu"},
+        }
+        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
+
+        result = agents_client.purchase_entitlement_from_balance("1aiu", duration=3600, tags=["customer=acme"])
+
+        assert result["grant"]["type"] == "BALANCE"
+        assert mock_client.post.call_args[0][0].endswith("/billing/balance/1aiu")
+        assert mock_client.post.call_args[1]["json"] == {"duration": 3600, "tags": ["customer=acme"]}
+
+
+def test_agents_redeem_grant_code(agents_client):
+    with patch("httpx.Client") as mock_client_class:
+        mock_client = MagicMock()
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "grant": {"id": "grant-1", "type": "ACTIVATION_CODE", "code": "promo-123"},
+            "entitlement": {"id": "ent-1", "plan_id": "1aiu"},
+        }
+        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
+
+        result = agents_client.redeem_grant_code("promo-123")
+
+        assert result["grant"]["code"] == "promo-123"
+        assert mock_client.post.call_args[0][0].endswith("/billing/grants/redeem")
+        assert mock_client.post.call_args[1]["json"] == {"code": "promo-123"}
+
+
 def test_openclaw_agent_resolve_gateway_token_uses_inference_endpoint():
     manager = Mock()
     manager.inference_token.return_value = {

{hypercli_sdk-2026.4.18 → hypercli_sdk-2026.4.20}/tests/test_claw.py

@@ -12,6 +12,7 @@ from hypercli.agent import (
     HyperAgentPlan,
     HyperAgentCurrentPlan,
     HyperAgentSubscription,
+    HyperAgentEntitlement,
     HyperAgentSubscriptionSummary,
     HyperAgentModel,
     HyperAgentUsageSummary,
@@ -99,6 +100,23 @@ class TestHyperAgentDataclasses:
                     "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",
@@ -369,6 +387,90 @@ class TestHyperAgentClient:
                 max_tokens=100
             )
 
+    def test_purchase_via_x402_uses_plan_route(self, mock_http):
+        agent = HyperAgent(
+            mock_http,
+            agent_api_key="sk-hyper-test",
+            agents_api_base_url="https://api.hypercli.com/agents",
+        )
+        mock_response = Mock()
+        mock_response.raise_for_status.return_value = None
+        mock_response.json.return_value = {
+            "ok": True,
+            "key": "hyper_api_x402",
+            "plan_id": "1aiu",
+            "quantity": 1,
+            "bundle": {"small": 1},
+            "amount_paid": "20.00",
+            "duration_days": 30,
+            "expires_at": "2026-05-19T12:00:00Z",
+            "tpm_limit": 1000,
+            "rpm_limit": 10,
+        }
+        mock_http._session.post.return_value = mock_response
+
+        result = agent.purchase_via_x402("1aiu", quantity=1, bundle={"small": 1})
+
+        assert result.plan_id == "1aiu"
+        assert mock_http._session.post.call_args[0][0] == "https://api.hypercli.com/agents/x402/1aiu"
+        assert mock_http._session.post.call_args[1]["json"] == {"quantity": 1, "bundle": {"small": 1}}
+
+    def test_purchase_bundle_via_x402_uses_bundle_route(self, mock_http):
+        agent = HyperAgent(
+            mock_http,
+            agent_api_key="sk-hyper-test",
+            agents_api_base_url="https://api.hypercli.com/agents",
+        )
+        mock_response = Mock()
+        mock_response.raise_for_status.return_value = None
+        mock_response.json.return_value = {
+            "ok": True,
+            "key": "hyper_api_x402",
+            "plan_id": "_bundle",
+            "quantity": 1,
+            "bundle": {"large": 2},
+            "amount_paid": "200.00",
+            "duration_days": 30,
+            "expires_at": "2026-05-19T12:00:00Z",
+            "tpm_limit": 1000,
+            "rpm_limit": 10,
+        }
+        mock_http._session.post.return_value = mock_response
+
+        result = agent.purchase_bundle_via_x402(quantity=1, bundle={"large": 2})
+
+        assert result.plan_id == "_bundle"
+        assert mock_http._session.post.call_args[0][0] == "https://api.hypercli.com/agents/x402/_bundle"
+        assert mock_http._session.post.call_args[1]["json"] == {"quantity": 1, "bundle": {"large": 2}}
+
+    def test_create_x402_checkout_is_bundle_shim(self, mock_http):
+        agent = HyperAgent(
+            mock_http,
+            agent_api_key="sk-hyper-test",
+            agents_api_base_url="https://api.hypercli.com/agents",
+        )
+        mock_response = Mock()
+        mock_response.raise_for_status.return_value = None
+        mock_response.json.return_value = {
+            "ok": True,
+            "key": "hyper_api_x402",
+            "plan_id": "_bundle",
+            "quantity": 1,
+            "bundle": {"medium": 1},
+            "amount_paid": "40.00",
+            "duration_days": 30,
+            "expires_at": "2026-05-19T12:00:00Z",
+            "tpm_limit": 1000,
+            "rpm_limit": 10,
+        }
+        mock_http._session.post.return_value = mock_response
+
+        result = agent.create_x402_checkout(quantity=1, bundle={"medium": 1})
+
+        assert result.plan_id == "_bundle"
+        assert mock_http._session.post.call_args[0][0] == "https://api.hypercli.com/agents/x402/_bundle"
+        assert mock_http._session.post.call_args[1]["json"] == {"quantity": 1, "bundle": {"medium": 1}}
+
 class TestHyperAgentIntegration:
     """Integration tests for HyperAgent client (require running service)."""