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

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

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

@@ -32,6 +32,7 @@ from .jobs import (
 )
 from .renders import Render, RenderStatus
 from .voice import VoiceAPI
+from .models import Model, ModelsAPI
 from .x402 import X402Client, X402JobLaunch, X402FlowCreate, X402RenderCreate, FlowCatalogItem
 from .files import File, AsyncFiles
 from .job import BaseJob, ComfyUIJob, GradioJob, apply_params, apply_graph_modes, find_node, find_nodes, load_template, graph_to_api, expand_subgraphs, DEFAULT_OBJECT_INFO
@@ -93,6 +94,8 @@ __all__ = [
     "Render",
     "RenderStatus",
     "VoiceAPI",
+    "Model",
+    "ModelsAPI",
     # x402 API
     "X402Client",
     "X402JobLaunch",

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

@@ -386,6 +386,32 @@ class Agent:
         self._deployments = agent._deployments
         return self
 
+    def update(
+        self,
+        *,
+        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":
+        agent = self._require_deployments().update(
+            self.id,
+            name=name,
+            size=size,
+            cpu=cpu,
+            memory=memory,
+            refresh_from_lagoon=refresh_from_lagoon,
+            last_error=last_error,
+        )
+        self.__dict__.update(agent.__dict__)
+        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 env(self) -> dict[str, str]:
         """Fetch runtime environment from the pod's K8s secret."""
         data = self._require_deployments().env(self.id)
@@ -1250,6 +1276,43 @@ class Deployments:
             dry_run=dry_run,
         )
 
+    def update(
+        self,
+        agent_id: str,
+        *,
+        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:
+        body: dict[str, Any] = {}
+        if name is not None:
+            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:
+            body["last_error"] = last_error
+        data = self._http.patch(f"{AGENTS_API_PREFIX}/{agent_id}", json=body)
+        return self._hydrate_agent(data)
+
+    def resize(
+        self,
+        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)
+
     def stop(self, agent_id: str) -> Agent:
         """Stop an agent (tears down pod, keeps DB record).
 

{hypercli_sdk-2026.4.7 → hypercli_sdk-2026.4.9}/hypercli/client.py

@@ -19,6 +19,7 @@ from .voice import VoiceAPI
 from .agents import Deployments
 from .agent import HyperAgent
 from .keys import KeysAPI
+from .models import ModelsAPI
 
 
 def _derive_agents_api_base(api_url: str, agent_dev: bool) -> str:
@@ -100,6 +101,7 @@ class HyperCLI:
         self.files = Files(self._http)
         self.voice = VoiceAPI(self._http)
         self.keys = KeysAPI(self._http)
+        self.models = ModelsAPI(self._http)
         self.agent = HyperAgent(
             self._http,
             agent_api_key=resolved_agent_api_key,

{hypercli_sdk-2026.4.7 → hypercli_sdk-2026.4.9}/hypercli/http.py

@@ -166,10 +166,10 @@ class HTTPClient:
         )
         return _handle_response(resp)
 
-    def post_bytes(self, path: str, json: dict = None) -> bytes:
+    def post_bytes(self, path: str, json: dict = None, timeout: float | None = None) -> bytes:
         resp = request_with_retry(
             "post", f"{self.base_url}{path}",
-            headers=self.headers, timeout=self.timeout, json=json
+            headers=self.headers, timeout=timeout if timeout is not None else self.timeout, json=json
         )
         return _handle_bytes_response(resp)
 

hypercli_sdk-2026.4.9/hypercli/models.py

@@ -0,0 +1,33 @@
+"""OpenAI-compatible models API"""
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, List
+
+if TYPE_CHECKING:
+    from .http import HTTPClient
+
+
+@dataclass
+class Model:
+    id: str
+    object: str
+    owned_by: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Model":
+        return cls(
+            id=data.get("id", ""),
+            object=data.get("object", "model"),
+            owned_by=data.get("owned_by"),
+        )
+
+
+class ModelsAPI:
+    """OpenAI-compatible models API"""
+
+    def __init__(self, http: "HTTPClient"):
+        self._http = http
+
+    def list(self) -> List[Model]:
+        payload = self._http.get("/v1/models")
+        data = payload.get("data") if isinstance(payload, dict) else payload
+        return [Model.from_dict(item) for item in (data or [])]

{hypercli_sdk-2026.4.7 → hypercli_sdk-2026.4.9}/hypercli/renders.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 """Renders API"""
 from dataclasses import dataclass
+from datetime import datetime, timezone
+import time
 from typing import TYPE_CHECKING, Any, List
 
 if TYPE_CHECKING:
@@ -56,11 +58,28 @@ class RenderStatus:
 class Renders:
     """Renders API wrapper"""
 
+    DEFAULT_WAIT_TIMEOUT = 3600.0
+    DEFAULT_QUEUE_GRACE = 1800.0
+    DEFAULT_ACTIVE_GRACE = 300.0
+
     def __init__(self, http: "HTTPClient", auth_http: "HTTPClient" | None = None):
         self._http = http
         self._auth_http = auth_http or http
         self._auth_me_cache: dict[str, Any] | None = None
 
+    @staticmethod
+    def _parse_render_timestamp(value: Any) -> float | None:
+        if value is None:
+            return None
+        if isinstance(value, (int, float)):
+            return float(value)
+        if isinstance(value, str):
+            try:
+                return datetime.fromisoformat(value.replace("Z", "+00:00")).astimezone(timezone.utc).timestamp()
+            except ValueError:
+                return None
+        return None
+
     def _auth_me(self) -> dict[str, Any]:
         if self._auth_me_cache is None:
             self._auth_me_cache = self._auth_http.get("/api/auth/me")
@@ -93,21 +112,21 @@ class Renders:
 
     def _get_render(self, render_id: str, *, status: bool = False) -> dict[str, Any]:
         suffix = "/status" if status else ""
-        primary = f"/agents/flow/renders/{render_id}{suffix}" if self._supports_subscription_family("flows") else f"/api/renders/{render_id}{suffix}"
+        primary = f"/agents/flow/renders/{render_id}{suffix}" if self._supports_subscription_family("flows") else f"/api/flow/renders/{render_id}{suffix}"
         try:
             return self._http.get(primary)
         except APIError as exc:
             if primary.startswith("/agents/flow/") and exc.status_code in {403, 404}:
-                return self._http.get(f"/api/renders/{render_id}{suffix}")
+                return self._http.get(f"/api/flow/renders/{render_id}{suffix}")
             raise
 
     def _delete_render(self, render_id: str) -> dict:
-        primary = f"/agents/flow/renders/{render_id}" if self._supports_subscription_family("flows") else f"/api/renders/{render_id}"
+        primary = f"/agents/flow/renders/{render_id}" if self._supports_subscription_family("flows") else f"/api/flow/renders/{render_id}"
         try:
             return self._http.delete(primary)
         except APIError as exc:
             if primary.startswith("/agents/flow/") and exc.status_code in {403, 404}:
-                return self._http.delete(f"/api/renders/{render_id}")
+                return self._http.delete(f"/api/flow/renders/{render_id}")
             raise
 
     def list(
@@ -179,6 +198,50 @@ class Renders:
         data = self._get_render(render_id, status=True)
         return RenderStatus.from_dict(data)
 
+    def wait(
+        self,
+        render_id: str,
+        timeout: float = DEFAULT_WAIT_TIMEOUT,
+        poll_interval: float = 5.0,
+        queue_grace: float = DEFAULT_QUEUE_GRACE,
+        active_grace: float = DEFAULT_ACTIVE_GRACE,
+    ) -> Render:
+        """Wait for a render to reach a terminal state.
+
+        This tolerates long queue times in shared dev environments by granting
+        one bounded queue grace window and one bounded active-runtime grace
+        window when the render only starts near the original deadline.
+        """
+        deadline = time.time() + timeout
+        queue_grace_used = False
+        active_grace_used = False
+        last_render: Render | None = None
+
+        while True:
+            render = self.get(render_id)
+            last_render = render
+            state = (render.state or "").lower()
+            if state in {"completed", "failed", "cancelled"}:
+                return render
+
+            now = time.time()
+            if now >= deadline:
+                started_at = self._parse_render_timestamp(render.started_at)
+                if not queue_grace_used and started_at is None:
+                    queue_grace_used = True
+                    deadline = now + queue_grace
+                elif not active_grace_used and started_at is not None:
+                    active_grace_used = True
+                    deadline = max(deadline, started_at + active_grace)
+                else:
+                    raise TimeoutError(
+                        f"Render {render_id} did not complete within {timeout:.0f}s "
+                        f"(+{queue_grace:.0f}s queue grace, +{active_grace:.0f}s active grace); "
+                        f"last_render={last_render}"
+                    )
+
+            time.sleep(poll_interval)
+
     # =========================================================================
     # Flow endpoints - simplified interfaces
     # =========================================================================

{hypercli_sdk-2026.4.7 → hypercli_sdk-2026.4.9}/hypercli/voice.py

@@ -20,6 +20,8 @@ def _encode_reference_audio(ref_audio: bytes | str | Path) -> str:
 class VoiceAPI:
     """Voice capability API wrapper."""
 
+    DEFAULT_TIMEOUT = 300.0
+
     def __init__(self, http: "HTTPClient"):
         self._http = http
 
@@ -30,6 +32,7 @@ class VoiceAPI:
         voice: str = "Chelsie",
         language: str = "auto",
         response_format: str = "mp3",
+        timeout: float = DEFAULT_TIMEOUT,
     ) -> bytes:
         return self._http.post_bytes(
             "/agents/voice/tts",
@@ -39,6 +42,7 @@ class VoiceAPI:
                 "language": language,
                 "response_format": response_format,
             },
+            timeout=timeout,
         )
 
     def clone(
@@ -49,6 +53,7 @@ class VoiceAPI:
         language: str = "auto",
         x_vector_only: bool = True,
         response_format: str = "mp3",
+        timeout: float = DEFAULT_TIMEOUT,
     ) -> bytes:
         return self._http.post_bytes(
             "/agents/voice/clone",
@@ -59,6 +64,7 @@ class VoiceAPI:
                 "x_vector_only": x_vector_only,
                 "response_format": response_format,
             },
+            timeout=timeout,
         )
 
     def design(
@@ -68,6 +74,7 @@ class VoiceAPI:
         description: str,
         language: str = "auto",
         response_format: str = "mp3",
+        timeout: float = DEFAULT_TIMEOUT,
     ) -> bytes:
         return self._http.post_bytes(
             "/agents/voice/design",
@@ -77,4 +84,5 @@ class VoiceAPI:
                 "language": language,
                 "response_format": response_format,
             },
+            timeout=timeout,
         )

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

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

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

@@ -9,37 +9,35 @@ 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")
+    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:
+        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
 
 
 def test_list_agents_requires_agent_key(client, test_agent_api_key: str):

{hypercli_sdk-2026.4.7 → hypercli_sdk-2026.4.9}/tests/integration/test_keys.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 import uuid
 
 import pytest
@@ -40,6 +38,19 @@ def test_create_and_disable_tagged_key(client):
     assert disabled["status"] == "deactivated"
 
 
+def test_created_key_authenticates_against_models_api(client, test_api_base: str):
+    name = f"sdk-models-scope-{uuid.uuid4().hex[:8]}"
+    created = client.keys.create(name=name, tags=["models:*"])
+
+    try:
+        scoped = HyperCLI(api_key=created.api_key, api_url=test_api_base)
+        models = scoped.models.list()
+        assert models
+        assert all(model.id for model in models)
+    finally:
+        client.keys.disable(created.key_id)
+
+
 def test_api_scoped_key_allows_key_admin_but_denies_profile(client, test_api_base: str):
     name = f"sdk-api-scope-{uuid.uuid4().hex[:8]}"
     created = client.keys.create(name=name, tags=["api:self"])

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

@@ -785,6 +785,77 @@ def test_agents_start_stop_delete(agents_client):
         assert agents_client.delete("agent-123") == {"status": "deleted"}
 
 
+def test_agents_update_and_resize(agents_client):
+    patch_calls = []
+
+    def fake_patch(path, json=None):
+        patch_calls.append((path, json))
+        return {
+            "id": "agent-123",
+            "user_id": "user-456",
+            "pod_id": None,
+            "pod_name": None,
+            "state": "stopped",
+            "cpu": 4,
+            "memory": 4,
+        }
+
+    agents_client._http.patch = fake_patch
+
+    updated = agents_client.update("agent-123", size="large", refresh_from_lagoon=True)
+    assert updated.id == "agent-123"
+    assert patch_calls[0] == (
+        "/deployments/agent-123",
+        {"size": "large", "refresh_from_lagoon": True},
+    )
+
+    resized = agents_client.resize("agent-123", size="large")
+    assert resized.id == "agent-123"
+    assert patch_calls[1] == ("/deployments/agent-123", {"size": "large"})
+
+
+def test_bound_agent_resize_delegates_to_deployments(agents_client):
+    patch_calls = []
+
+    def fake_patch(path, json=None):
+        patch_calls.append((path, json))
+        return {
+            "id": "agent-123",
+            "user_id": "user-456",
+            "pod_id": None,
+            "pod_name": None,
+            "state": "stopped",
+            "cpu": 4,
+            "memory": 4,
+        }
+
+    agents_client._http.patch = fake_patch
+
+    with patch("httpx.Client") as mock_client_class:
+        mock_client = MagicMock()
+        get_response = Mock()
+        get_response.status_code = 200
+        get_response.json.return_value = {
+            "id": "agent-123",
+            "user_id": "user-456",
+            "pod_id": None,
+            "pod_name": None,
+            "state": "stopped",
+            "cpu": 2,
+            "memory": 2,
+        }
+        mock_client.get.return_value = get_response
+        mock_client.__enter__.return_value = mock_client
+        mock_client.__exit__.return_value = False
+        mock_client_class.return_value = mock_client
+
+        agent = agents_client.get("agent-123")
+        resized = agent.resize(size="large")
+
+        assert resized.cpu == 4
+        assert patch_calls == [("/deployments/agent-123", {"size": "large"})]
+
+
 def test_agents_start_preserves_generic_launch_fields(agents_client):
     with patch("httpx.Client") as mock_client_class, patch("hypercli.agents.secrets.token_hex", return_value="gw-token-generic"):
         mock_client = MagicMock()

hypercli_sdk-2026.4.9/tests/test_models.py

@@ -0,0 +1,27 @@
+from hypercli.models import ModelsAPI
+
+
+class DummyHTTP:
+    def __init__(self):
+        self.calls = []
+
+    def get(self, path):
+        self.calls.append(("get", path, None))
+        assert path == "/v1/models"
+        return {
+            "object": "list",
+            "data": [
+                {"id": "glm-5", "object": "model", "owned_by": "hypercli"},
+                {"id": "kimi-k2.5", "object": "model", "owned_by": "hypercli"},
+            ],
+        }
+
+
+def test_models_list_reads_openai_models_payload():
+    http = DummyHTTP()
+    models = ModelsAPI(http)
+
+    listed = models.list()
+
+    assert [model.id for model in listed] == ["glm-5", "kimi-k2.5"]
+    assert http.calls == [("get", "/v1/models", None)]

hypercli_sdk-2026.4.9/tests/test_renders_subscription.py

@@ -0,0 +1,188 @@
+from hypercli.http import APIError
+from hypercli.renders import Renders
+from hypercli.http import APIError
+
+
+class DummyHTTP:
+    def __init__(self):
+        self.calls = []
+        self.fail_once = {}
+
+    def get(self, path, params=None):
+        self.calls.append(("get", path, params))
+        if path == "/api/auth/me":
+            return self.auth_me
+        if path.endswith("/status"):
+            render_id = path.split("/")[-2]
+            return {"id": render_id, "state": "running", "progress": 0.5}
+        render_id = path.split("/")[-1]
+        return {"id": render_id, "state": "queued"}
+
+    def post(self, path, json=None):
+        self.calls.append(("post", path, json))
+        if self.fail_once.get(path):
+            error = self.fail_once.pop(path)
+            raise error
+        return {"id": "render-123", "state": "queued"}
+
+    def delete(self, path):
+        self.calls.append(("delete", path, None))
+        if self.fail_once.get(path):
+            error = self.fail_once.pop(path)
+            raise error
+        return {"status": "cancelled"}
+
+
+class Clock:
+    def __init__(self):
+        self.now = 0.0
+
+    def time(self):
+        return self.now
+
+    def sleep(self, seconds):
+        self.now += seconds
+
+
+def test_create_flow_uses_subscription_route_when_available():
+    http = DummyHTTP()
+    http.auth_me = {
+        "auth_type": "orchestra_key",
+        "capabilities": ["flows:*"],
+        "has_active_subscription": True,
+    }
+    renders = Renders(http)
+
+    render = renders.create_flow("text-to-image", prompt="hello")
+
+    assert render.render_id == "render-123"
+    assert http.calls[0] == ("get", "/api/auth/me", None)
+    assert http.calls[1] == ("post", "/agents/flow/text-to-image", {"prompt": "hello"})
+
+
+def test_create_flow_falls_back_to_paid_route_on_subscription_rejection():
+    http = DummyHTTP()
+    http.auth_me = {
+        "auth_type": "orchestra_key",
+        "capabilities": ["flows:*"],
+        "has_active_subscription": True,
+    }
+    http.fail_once["/agents/flow/text-to-image"] = APIError(403, "Active paid subscription required")
+    renders = Renders(http)
+
+    render = renders.create_flow("text-to-image", prompt="hello")
+
+    assert render.render_id == "render-123"
+    assert http.calls[1] == ("post", "/agents/flow/text-to-image", {"prompt": "hello"})
+    assert http.calls[2] == ("post", "/api/flow/text-to-image", {"prompt": "hello"})
+
+
+def test_get_status_and_cancel_prefer_subscription_render_routes():
+    http = DummyHTTP()
+    http.auth_me = {
+        "auth_type": "user",
+        "capabilities": [],
+        "has_active_subscription": True,
+    }
+    renders = Renders(http)
+
+    render = renders.get("render-123")
+    status = renders.status("render-123")
+    cancelled = renders.cancel("render-123")
+
+    assert render.render_id == "render-123"
+    assert status.progress == 0.5
+    assert cancelled["status"] == "cancelled"
+    assert ("get", "/agents/flow/renders/render-123", None) in http.calls
+    assert ("get", "/agents/flow/renders/render-123/status", None) in http.calls
+    assert ("delete", "/agents/flow/renders/render-123", None) in http.calls
+
+
+def test_flow_only_keys_fallback_to_api_flow_render_routes_when_auth_me_is_denied():
+    calls = []
+
+    class FlowHTTP:
+        def get(self, path, params=None):
+            calls.append(("get", path, params))
+            if path == "/api/auth/me":
+                raise APIError(status_code=403, detail="Access denied", response_text='{"detail":"Access denied"}')
+            return {"id": "render-123", "state": "queued"}
+
+        def delete(self, path):
+            calls.append(("delete", path, None))
+            return {"status": "cancelled"}
+
+    renders = Renders(FlowHTTP())
+
+    render = renders.get("render-123")
+    status = renders.status("render-123")
+    cancelled = renders.cancel("render-123")
+
+    assert render.render_id == "render-123"
+    assert status.render_id == "render-123"
+    assert cancelled["status"] == "cancelled"
+    assert ("get", "/api/flow/renders/render-123", None) in calls
+    assert ("get", "/api/flow/renders/render-123/status", None) in calls
+    assert ("delete", "/api/flow/renders/render-123", None) in calls
+
+
+def test_wait_allows_queue_grace(monkeypatch):
+    http = DummyHTTP()
+    http.auth_me = {
+        "auth_type": "user",
+        "capabilities": [],
+        "has_active_subscription": True,
+    }
+    clock = Clock()
+    calls = {"count": 0}
+
+    def fake_get(path, params=None):
+        http.calls.append(("get", path, params))
+        if path == "/api/auth/me":
+            return http.auth_me
+        calls["count"] += 1
+        if calls["count"] <= 3:
+            return {"id": "render-123", "state": "running", "started_at": None}
+        return {"id": "render-123", "state": "completed", "started_at": "1970-01-01T00:00:15+00:00"}
+
+    monkeypatch.setattr(http, "get", fake_get)
+    monkeypatch.setattr("hypercli.renders.time.time", clock.time)
+    monkeypatch.setattr("hypercli.renders.time.sleep", clock.sleep)
+    renders = Renders(http)
+
+    render = renders.wait("render-123", timeout=10, poll_interval=5, queue_grace=10, active_grace=5)
+
+    assert render.state == "completed"
+    assert clock.time() == 15
+
+
+def test_wait_allows_recent_active_grace(monkeypatch):
+    http = DummyHTTP()
+    http.auth_me = {
+        "auth_type": "user",
+        "capabilities": [],
+        "has_active_subscription": True,
+    }
+    clock = Clock()
+    calls = {"count": 0}
+
+    def fake_get(path, params=None):
+        http.calls.append(("get", path, params))
+        if path == "/api/auth/me":
+            return http.auth_me
+        calls["count"] += 1
+        if calls["count"] == 1:
+            return {"id": "render-123", "state": "running", "started_at": None}
+        if calls["count"] == 2:
+            return {"id": "render-123", "state": "running", "started_at": "1970-01-01T00:00:04+00:00"}
+        return {"id": "render-123", "state": "completed", "started_at": "1970-01-01T00:00:04+00:00"}
+
+    monkeypatch.setattr(http, "get", fake_get)
+    monkeypatch.setattr("hypercli.renders.time.time", clock.time)
+    monkeypatch.setattr("hypercli.renders.time.sleep", clock.sleep)
+    renders = Renders(http)
+
+    render = renders.wait("render-123", timeout=5, poll_interval=5, queue_grace=5, active_grace=6)
+
+    assert render.state == "completed"
+    assert clock.time() == 10

{hypercli_sdk-2026.4.7 → hypercli_sdk-2026.4.9}/tests/test_voice.py

@@ -7,8 +7,8 @@ class DummyVoiceHTTP:
     def __init__(self):
         self.calls = []
 
-    def post_bytes(self, path, json=None):
-        self.calls.append((path, json))
+    def post_bytes(self, path, json=None, timeout=None):
+        self.calls.append((path, json, timeout))
         return b"audio-bytes"
 
 
@@ -28,6 +28,7 @@ def test_voice_tts_posts_to_agents_voice_prefix():
                 "language": "english",
                 "response_format": "wav",
             },
+            VoiceAPI.DEFAULT_TIMEOUT,
         )
     ]
 
@@ -42,11 +43,12 @@ def test_voice_clone_base64_encodes_reference(tmp_path: Path):
     audio = voice.clone("clone me", ref_audio=ref, response_format="wav")
 
     assert audio == b"audio-bytes"
-    path, payload = http.calls[0]
+    path, payload, timeout = http.calls[0]
     assert path == "/agents/voice/clone"
     assert payload["text"] == "clone me"
     assert payload["response_format"] == "wav"
     assert payload["ref_audio_base64"] == "cmVmZXJlbmNlLWF1ZGlv"
+    assert timeout == VoiceAPI.DEFAULT_TIMEOUT
 
 
 def test_voice_design_posts_description():
@@ -65,5 +67,6 @@ def test_voice_design_posts_description():
                 "language": "auto",
                 "response_format": "wav",
             },
+            VoiceAPI.DEFAULT_TIMEOUT,
         )
     ]

hypercli_sdk-2026.4.7/tests/test_renders_subscription.py

@@ -1,86 +0,0 @@
-from hypercli.http import APIError
-from hypercli.renders import Renders
-
-
-class DummyHTTP:
-    def __init__(self):
-        self.calls = []
-        self.fail_once = {}
-
-    def get(self, path, params=None):
-        self.calls.append(("get", path, params))
-        if path == "/api/auth/me":
-            return self.auth_me
-        if path.endswith("/status"):
-            render_id = path.split("/")[-2]
-            return {"id": render_id, "state": "running", "progress": 0.5}
-        render_id = path.split("/")[-1]
-        return {"id": render_id, "state": "queued"}
-
-    def post(self, path, json=None):
-        self.calls.append(("post", path, json))
-        if self.fail_once.get(path):
-            error = self.fail_once.pop(path)
-            raise error
-        return {"id": "render-123", "state": "queued"}
-
-    def delete(self, path):
-        self.calls.append(("delete", path, None))
-        if self.fail_once.get(path):
-            error = self.fail_once.pop(path)
-            raise error
-        return {"status": "cancelled"}
-
-
-def test_create_flow_uses_subscription_route_when_available():
-    http = DummyHTTP()
-    http.auth_me = {
-        "auth_type": "orchestra_key",
-        "capabilities": ["flows:*"],
-        "has_active_subscription": True,
-    }
-    renders = Renders(http)
-
-    render = renders.create_flow("text-to-image", prompt="hello")
-
-    assert render.render_id == "render-123"
-    assert http.calls[0] == ("get", "/api/auth/me", None)
-    assert http.calls[1] == ("post", "/agents/flow/text-to-image", {"prompt": "hello"})
-
-
-def test_create_flow_falls_back_to_paid_route_on_subscription_rejection():
-    http = DummyHTTP()
-    http.auth_me = {
-        "auth_type": "orchestra_key",
-        "capabilities": ["flows:*"],
-        "has_active_subscription": True,
-    }
-    http.fail_once["/agents/flow/text-to-image"] = APIError(403, "Active paid subscription required")
-    renders = Renders(http)
-
-    render = renders.create_flow("text-to-image", prompt="hello")
-
-    assert render.render_id == "render-123"
-    assert http.calls[1] == ("post", "/agents/flow/text-to-image", {"prompt": "hello"})
-    assert http.calls[2] == ("post", "/api/flow/text-to-image", {"prompt": "hello"})
-
-
-def test_get_status_and_cancel_prefer_subscription_render_routes():
-    http = DummyHTTP()
-    http.auth_me = {
-        "auth_type": "user",
-        "capabilities": [],
-        "has_active_subscription": True,
-    }
-    renders = Renders(http)
-
-    render = renders.get("render-123")
-    status = renders.status("render-123")
-    cancelled = renders.cancel("render-123")
-
-    assert render.render_id == "render-123"
-    assert status.progress == 0.5
-    assert cancelled["status"] == "cancelled"
-    assert ("get", "/agents/flow/renders/render-123", None) in http.calls
-    assert ("get", "/agents/flow/renders/render-123/status", None) in http.calls
-    assert ("delete", "/agents/flow/renders/render-123", None) in http.calls