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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypercli-sdk
-Version: 2026.4.5
+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.5 → 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.5"
+__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.5 → 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.5 → hypercli_sdk-2026.4.7}/hypercli/client.py

@@ -86,7 +86,6 @@ class HyperCLI:
             agents_ws_url
             or (_derive_agents_ws_url(self._api_url, agent_dev) if api_url else get_agents_ws_url(agent_dev))
         )
-        auth_http = HTTPClient(resolved_agents_api_base, self._api_key)
         self.deployments = Deployments(
             self._http,
             api_key=resolved_agent_api_key,
@@ -95,9 +94,9 @@ class HyperCLI:
         )
         self.billing = Billing(self._http)
         self.jobs = Jobs(self._http)
-        self.user = UserAPI(self._http, auth_http=auth_http)
+        self.user = UserAPI(self._http)
         self.instances = Instances(self._http)
-        self.renders = Renders(self._http, auth_http=auth_http)
+        self.renders = Renders(self._http)
         self.files = Files(self._http)
         self.voice = VoiceAPI(self._http)
         self.keys = KeysAPI(self._http)

{hypercli_sdk-2026.4.5 → 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.5 → hypercli_sdk-2026.4.7}/hypercli/renders.py

@@ -63,7 +63,7 @@ class Renders:
 
     def _auth_me(self) -> dict[str, Any]:
         if self._auth_me_cache is None:
-            self._auth_me_cache = self._auth_http.get("/auth/me")
+            self._auth_me_cache = self._auth_http.get("/api/auth/me")
         return self._auth_me_cache
 
     def _supports_subscription_family(self, family: str, resource: str | None = None) -> bool:
@@ -83,7 +83,7 @@ class Renders:
         return False
 
     def _post_flow(self, flow_type: str, payload: dict[str, Any]) -> dict[str, Any]:
-        primary = f"/agents/flow/{flow_type}" if self._supports_subscription_family("renders", flow_type) else f"/api/flow/{flow_type}"
+        primary = f"/agents/flow/{flow_type}" if self._supports_subscription_family("flows", flow_type) else f"/api/flow/{flow_type}"
         try:
             return self._http.post(primary, json=payload)
         except APIError as exc:
@@ -93,7 +93,7 @@ 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("renders") else f"/api/renders/{render_id}{suffix}"
+        primary = f"/agents/flow/renders/{render_id}{suffix}" if self._supports_subscription_family("flows") else f"/api/renders/{render_id}{suffix}"
         try:
             return self._http.get(primary)
         except APIError as exc:
@@ -102,7 +102,7 @@ class Renders:
             raise
 
     def _delete_render(self, render_id: str) -> dict:
-        primary = f"/agents/flow/renders/{render_id}" if self._supports_subscription_family("renders") else f"/api/renders/{render_id}"
+        primary = f"/agents/flow/renders/{render_id}" if self._supports_subscription_family("flows") else f"/api/renders/{render_id}"
         try:
             return self._http.delete(primary)
         except APIError as exc:

{hypercli_sdk-2026.4.5 → hypercli_sdk-2026.4.7}/hypercli/user.py

@@ -68,5 +68,5 @@ class UserAPI:
 
     def auth_me(self) -> AuthMe:
         """Resolve the current auth context, including key capabilities."""
-        data = self._auth_http.get("/auth/me")
+        data = self._auth_http.get("/api/auth/me")
         return AuthMe.from_dict(data)

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hypercli-sdk"
-version = "2026.4.5"
+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.5 → 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