getstack 0.5.1__tar.gz → 0.6.0__tar.gz

{getstack-0.5.1 → getstack-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: getstack
-Version: 0.5.1
+Version: 0.6.0
 Summary: Python SDK for STACK — trust infrastructure for AI agents
 Project-URL: Homepage, https://getstack.run
 Project-URL: Documentation, https://getstack.run/docs/sdk

{getstack-0.5.1 → getstack-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "getstack"
-version = "0.5.1"
+version = "0.6.0"
 description = "Python SDK for STACK — trust infrastructure for AI agents"
 readme = "README.md"
 license = "MIT"

{getstack-0.5.1 → getstack-0.6.0}/src/getstack/__init__.py

@@ -256,15 +256,31 @@ class Stack:
 class AsyncStack:
     """Asynchronous STACK client.
 
-    Uses httpx.AsyncClient under the hood. All service methods are sync
-    (they use the sync HttpClient wrapper) — for true async, the async
-    client needs async service modules. This provides the async HTTP
-    transport layer for future async service implementations.
+    Sub-chunk 2.4 — full parity with Stack. All 14 typed services are
+    async-native, plus AsyncMission for the bounded-mission context
+    manager. Uses httpx.AsyncClient under the hood.
 
     Args:
         api_key: A STACK API key (``sk_live_...``).
         base_url: Override the API base URL.
         timeout: HTTP timeout in seconds.
+
+    Example::
+
+        from getstack import AsyncStack
+
+        async with AsyncStack(api_key="sk_live_...") as stack:
+            agents = await stack.agents.list()
+            async with stack.passports.mission(
+                agent_id=agents[0].id,
+                intent="Process invoices",
+                services=["slack", "stripe"],
+            ) as mission:
+                resp = await mission.proxy(
+                    "stripe", "https://api.stripe.com/v1/charges",
+                    method="POST", body={"amount": 50},
+                    _proxy_service=stack.proxy,
+                )
     """
 
     def __init__(
@@ -293,6 +309,39 @@ class AsyncStack:
 
         self._client = AsyncHttpClient(auth, base_url=base_url, timeout=timeout)
 
+        # Sub-chunk 2.4 — 14 typed async services attached eagerly,
+        # matching Stack's posture. Footprint is small; lazy init
+        # would only buy us memory we don't need to save.
+        from ._async.agents import AsyncAgentService
+        from ._async.passports import AsyncPassportService
+        from ._async.credentials import AsyncCredentialService
+        from ._async.services import AsyncServiceService
+        from ._async.dropoffs import AsyncDropoffService
+        from ._async.reviews import AsyncReviewService
+        from ._async.notifications import AsyncNotificationService
+        from ._async.audit import AsyncAuditService
+        from ._async.proxy import AsyncProxyService
+        from ._async.scan import AsyncScanService
+        from ._async.security_events import AsyncSecurityEventService
+        from ._async.skills import AsyncSkillService
+        from ._async.identity import AsyncIdentityService
+        from ._async.intents import AsyncIntentsService
+
+        self.agents = AsyncAgentService(self._client)
+        self.passports = AsyncPassportService(self._client)
+        self.credentials = AsyncCredentialService(self._client)
+        self.services = AsyncServiceService(self._client)
+        self.dropoffs = AsyncDropoffService(self._client)
+        self.reviews = AsyncReviewService(self._client)
+        self.notifications = AsyncNotificationService(self._client)
+        self.audit = AsyncAuditService(self._client)
+        self.proxy = AsyncProxyService(self._client)
+        self.scan = AsyncScanService(self._client)
+        self.security_events = AsyncSecurityEventService(self._client)
+        self.skills = AsyncSkillService(self._client)
+        self.identity = AsyncIdentityService(self._client)
+        self.intents = AsyncIntentsService(self._client)
+
     @classmethod
     def from_session(cls, session_token: str, **kwargs) -> AsyncStack:
         """Create an async client authenticated with a session JWT."""

getstack-0.6.0/src/getstack/_async/__init__.py

@@ -0,0 +1,14 @@
+"""Async service modules (Sub-chunk 2.4 — full parity with sync).
+
+Each AsyncXxxService mirrors the sync XxxService surface exactly:
+same method names, same kwargs, same return types. The only
+difference is `async def` and `await self._client.x` instead of
+`self._client.x`. The Mission ergonomic gets an AsyncMission
+context manager that uses asyncio.create_task + asyncio.sleep
+instead of threading.Timer.
+
+Import via AsyncStack:
+    from getstack import AsyncStack
+    async with AsyncStack(api_key="sk_live_...") as stack:
+        agents = await stack.agents.list()
+"""

getstack-0.6.0/src/getstack/_async/agents.py

@@ -0,0 +1,53 @@
+"""Async mirror of AgentService."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..client import AsyncHttpClient
+from ..types import Agent
+from ..agents import _to_agent
+
+
+class AsyncAgentService:
+    def __init__(self, client: AsyncHttpClient):
+        self._client = client
+
+    async def register(
+        self,
+        name: str,
+        description: str | None = None,
+        accountability_mode: str = "enforced",
+        on_warning: str = "notify",
+        on_critical: str = "notify",
+    ) -> Agent:
+        body: dict[str, Any] = {"name": name, "accountability_mode": accountability_mode}
+        if description:
+            body["description"] = description
+        if on_warning != "notify":
+            body["on_warning"] = on_warning
+        if on_critical != "notify":
+            body["on_critical"] = on_critical
+        return _to_agent(await self._client.post("/v1/agents/register", json=body))
+
+    async def get(self, agent_id: str) -> Agent:
+        return _to_agent(await self._client.get(f"/v1/agents/{agent_id}"))
+
+    async def list(self) -> list[Agent]:
+        data = await self._client.get("/v1/agents")
+        return [_to_agent(a) for a in data]
+
+    async def update(self, agent_id: str, **kwargs: Any) -> Agent:
+        return _to_agent(await self._client.patch(f"/v1/agents/{agent_id}", json=kwargs))
+
+    async def suspend(self, agent_id: str) -> Agent:
+        return await self.update(agent_id, status="suspended")
+
+    async def activate(self, agent_id: str) -> Agent:
+        return await self.update(agent_id, status="active")
+
+    async def delete(self, agent_id: str) -> dict[str, Any]:
+        return await self._client.delete(f"/v1/agents/{agent_id}")
+
+    async def unblock(self, agent_id: str) -> dict[str, Any]:
+        return await self._client.post(f"/v1/agents/{agent_id}/unblock")

getstack-0.6.0/src/getstack/_async/audit.py

@@ -0,0 +1,46 @@
+"""Async mirror of AuditService."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..client import AsyncHttpClient
+
+
+class AsyncAuditService:
+    def __init__(self, client: AsyncHttpClient):
+        self._client = client
+
+    async def list(
+        self,
+        limit: int = 20,
+        since: int | None = None,
+        agent_id: str | None = None,
+        passport_jti: str | None = None,
+    ) -> dict[str, Any]:
+        params: dict[str, str] = {"limit": str(limit)}
+        if since is not None:
+            params["since"] = str(since)
+        if agent_id is not None:
+            params["agent_id"] = agent_id
+        if passport_jti is not None:
+            params["passport_jti"] = passport_jti
+        return await self._client.get("/v1/audit", params=params)
+
+    async def chain_head(self) -> dict[str, Any]:
+        return await self._client.get("/v1/audit/chain-head")
+
+    async def verify_chain(
+        self,
+        from_date: str | None = None,
+        to_date: str | None = None,
+        limit: int | None = None,
+    ) -> dict[str, Any]:
+        params: dict[str, str] = {}
+        if from_date is not None:
+            params["from"] = from_date
+        if to_date is not None:
+            params["to"] = to_date
+        if limit is not None:
+            params["limit"] = str(limit)
+        return await self._client.get("/v1/audit/verify-chain", params=params)

getstack-0.6.0/src/getstack/_async/credentials.py

@@ -0,0 +1,43 @@
+"""Async mirror of CredentialService."""
+
+from __future__ import annotations
+
+from urllib.parse import quote
+
+from ..client import AsyncHttpClient
+from ..types import Credential
+
+
+class AsyncCredentialService:
+    def __init__(self, client: AsyncHttpClient):
+        self._client = client
+
+    async def get(self, provider: str, passport_token: str | None = None) -> Credential:
+        extra_headers: dict[str, str] = {}
+        if passport_token:
+            extra_headers["X-Passport-Token"] = passport_token
+        data = await self._client.get(
+            f"/v1/credentials/{quote(provider)}",
+            extra_headers=extra_headers if extra_headers else None,
+        )
+        return Credential(
+            provider=data["provider"],
+            credential=data.get("credential"),
+            credentials=data.get("credentials"),
+        )
+
+    async def get_by_connection(
+        self, connection_id: str, passport_token: str | None = None
+    ) -> Credential:
+        extra_headers: dict[str, str] = {}
+        if passport_token:
+            extra_headers["X-Passport-Token"] = passport_token
+        data = await self._client.get(
+            f"/v1/credentials/by-connection/{connection_id}",
+            extra_headers=extra_headers if extra_headers else None,
+        )
+        return Credential(
+            provider=data["provider"],
+            credential=data.get("credential"),
+            credentials=data.get("credentials"),
+        )

getstack-0.6.0/src/getstack/_async/dropoffs.py

@@ -0,0 +1,49 @@
+"""Async mirror of DropoffService."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..client import AsyncHttpClient
+
+
+class AsyncDropoffService:
+    def __init__(self, client: AsyncHttpClient):
+        self._client = client
+
+    async def create(
+        self,
+        from_agent_id: str,
+        to_agent_id: str,
+        schema: dict[str, Any],
+        ttl_seconds: int | None = None,
+        on_expire: str | None = None,
+    ) -> dict[str, Any]:
+        body: dict[str, Any] = {
+            "from_agent": from_agent_id,
+            "to_agent": to_agent_id,
+            "schema": schema,
+        }
+        if ttl_seconds:
+            body["ttl_seconds"] = ttl_seconds
+        if on_expire:
+            body["on_expire"] = on_expire
+        return await self._client.post("/v1/dropoffs", json=body)
+
+    async def deposit(self, dropoff_id: str, data: dict[str, Any], agent_id: str) -> dict[str, Any]:
+        return await self._client.post(
+            f"/v1/dropoffs/{dropoff_id}/deposit",
+            json={"agent_id": agent_id, "payload": data},
+        )
+
+    async def collect(self, dropoff_id: str, agent_id: str) -> dict[str, Any]:
+        return await self._client.post(
+            f"/v1/dropoffs/{dropoff_id}/collect",
+            json={"agent_id": agent_id},
+        )
+
+    async def get(self, dropoff_id: str) -> dict[str, Any]:
+        return await self._client.get(f"/v1/dropoffs/{dropoff_id}")
+
+    async def list(self) -> list[dict[str, Any]]:
+        return await self._client.get("/v1/dropoffs")

getstack-0.6.0/src/getstack/_async/identity.py

@@ -0,0 +1,92 @@
+"""Async mirror of IdentityService."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..client import AsyncHttpClient
+from ..types import IdentityProvider, IdentityClaim, IdentitySettings, VerificationSession
+from ..identity import _to_provider, _to_claim
+
+
+class AsyncIdentityService:
+    def __init__(self, client: AsyncHttpClient):
+        self._client = client
+
+    async def get_settings(self) -> IdentitySettings:
+        data = await self._client.get("/v1/operators/me/identity-settings")
+        return IdentitySettings(
+            identity_claim_ttl=data["identity_claim_ttl"],
+            identity_claim_inheritance=data["identity_claim_inheritance"],
+            identity_auto_revoke=data["identity_auto_revoke"],
+        )
+
+    async def update_settings(
+        self,
+        *,
+        identity_claim_ttl: str | None = None,
+        identity_claim_inheritance: str | None = None,
+        identity_auto_revoke: bool | None = None,
+    ) -> IdentitySettings:
+        body: dict[str, Any] = {}
+        if identity_claim_ttl is not None:
+            body["identity_claim_ttl"] = identity_claim_ttl
+        if identity_claim_inheritance is not None:
+            body["identity_claim_inheritance"] = identity_claim_inheritance
+        if identity_auto_revoke is not None:
+            body["identity_auto_revoke"] = identity_auto_revoke
+        data = await self._client.patch("/v1/operators/me/identity-settings", json=body)
+        return IdentitySettings(
+            identity_claim_ttl=data["identity_claim_ttl"],
+            identity_claim_inheritance=data["identity_claim_inheritance"],
+            identity_auto_revoke=data["identity_auto_revoke"],
+        )
+
+    async def list_providers(self) -> list[IdentityProvider]:
+        data = await self._client.get("/v1/identity/providers")
+        return [_to_provider(p) for p in data]
+
+    async def initiate_verification(
+        self,
+        provider_key: str,
+        *,
+        requested_claims: list[str] | None = None,
+        return_url: str | None = None,
+    ) -> VerificationSession:
+        body: dict[str, Any] = {"provider_key": provider_key}
+        if requested_claims:
+            body["requested_claims"] = requested_claims
+        if return_url:
+            body["return_url"] = return_url
+        data = await self._client.post("/v1/identity/verify/initiate", json=body)
+        return VerificationSession(
+            session_ref=data["session_ref"],
+            authorization_url=data.get("authorization_url"),
+            status=data.get("status", "pending"),
+        )
+
+    async def complete_verification(self, provider_key: str, session_ref: str) -> dict[str, Any]:
+        return await self._client.post(
+            "/v1/identity/verify/complete",
+            json={"provider_key": provider_key, "session_ref": session_ref},
+        )
+
+    async def grant_delegation(self, delegated_scopes: list[str]) -> IdentityClaim:
+        data = await self._client.post(
+            "/v1/identity/delegate",
+            json={"delegated_scopes": delegated_scopes},
+        )
+        return _to_claim(data)
+
+    async def list_claims(self) -> list[IdentityClaim]:
+        data = await self._client.get("/v1/identity/claims")
+        return [_to_claim(c) for c in data]
+
+    async def revoke_claim(self, claim_id: str) -> dict[str, Any]:
+        return await self._client.delete(f"/v1/identity/claims/{claim_id}")
+
+    async def get_service_requirements(self, service_id: str) -> dict[str, Any]:
+        return await self._client.get(f"/v1/services/{service_id}/requirements")
+
+    async def set_service_requirement(self, service_id: str, **kwargs: Any) -> dict[str, Any]:
+        return await self._client.post(f"/v1/services/{service_id}/requirements", json=kwargs)

getstack-0.6.0/src/getstack/_async/intents.py

@@ -0,0 +1,128 @@
+"""Async mirror of IntentsService. asyncio.sleep for the poll loop."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+from ..client import AsyncHttpClient
+
+
+class AsyncIntentsService:
+    def __init__(self, client: AsyncHttpClient):
+        self._client = client
+
+    async def simulate(
+        self,
+        intent: dict[str, Any],
+        passport_token: str,
+        *,
+        intent_claim_ref: str | None = None,
+        persist: bool | None = None,
+    ) -> dict[str, Any]:
+        body: dict[str, Any] = {"intent": intent}
+        if intent_claim_ref is not None:
+            body["intent_claim_ref"] = intent_claim_ref
+        if persist is not None:
+            body["persist"] = persist
+        return await self._client.request(
+            "POST",
+            "/v1/intents/simulate",
+            json=body,
+            extra_headers={"X-Passport-Token": passport_token},
+        )
+
+    async def submit(
+        self,
+        intent: dict[str, Any],
+        passport_token: str,
+        *,
+        expires_in_seconds: int | None = None,
+        skip_simulation: bool = False,
+    ) -> dict[str, Any]:
+        body: dict[str, Any] = {"intent": intent}
+        if expires_in_seconds is not None:
+            body["expires_in_seconds"] = expires_in_seconds
+        if skip_simulation:
+            body["skip_simulation"] = True
+        return await self._client.request(
+            "POST",
+            "/v1/intents/submit",
+            json=body,
+            extra_headers={"X-Passport-Token": passport_token},
+        )
+
+    async def submit_and_wait(
+        self,
+        intent: dict[str, Any],
+        passport_token: str,
+        *,
+        expires_in_seconds: int | None = None,
+        skip_simulation: bool = False,
+        timeout_seconds: float = 60.0,
+        poll_interval_seconds: float = 1.0,
+    ) -> dict[str, Any]:
+        """Async submit + poll. Uses asyncio.sleep instead of time.sleep
+        so the event loop stays free during the wait."""
+        initial = await self.submit(
+            intent,
+            passport_token,
+            expires_in_seconds=expires_in_seconds,
+            skip_simulation=skip_simulation,
+        )
+        approval_id = initial["approval_id"]
+        loop = asyncio.get_event_loop()
+        deadline = loop.time() + timeout_seconds
+        last_row: dict[str, Any] | None = None
+        while loop.time() < deadline:
+            row = await self.get(approval_id)
+            last_row = row
+            if row.get("status") != "pending":
+                return {"initial": initial, "final": row, "timed_out": False}
+            await asyncio.sleep(poll_interval_seconds)
+        return {
+            "initial": initial,
+            "final": last_row or {"id": approval_id, "status": "pending"},
+            "timed_out": True,
+        }
+
+    async def get(self, approval_id: str) -> dict[str, Any]:
+        return await self._client.request("GET", f"/v1/intents/{approval_id}")
+
+    async def list_pending(
+        self, *, page: int | None = None, limit: int | None = None
+    ) -> dict[str, Any]:
+        params: dict[str, Any] = {}
+        if page is not None:
+            params["page"] = page
+        if limit is not None:
+            params["limit"] = limit
+        return await self._client.request("GET", "/v1/intents/pending", params=params or None)
+
+    async def approve(self, approval_id: str, *, notes: str | None = None) -> dict[str, Any]:
+        body: dict[str, Any] = {}
+        if notes is not None:
+            body["notes"] = notes
+        return await self._client.request(
+            "POST",
+            f"/v1/intents/{approval_id}/approve",
+            json=body,
+        )
+
+    async def reject(
+        self,
+        approval_id: str,
+        *,
+        notes: str | None = None,
+        block_future: bool = False,
+    ) -> dict[str, Any]:
+        body: dict[str, Any] = {}
+        if notes is not None:
+            body["notes"] = notes
+        if block_future:
+            body["block_future"] = True
+        return await self._client.request(
+            "POST",
+            f"/v1/intents/{approval_id}/reject",
+            json=body,
+        )

getstack-0.6.0/src/getstack/_async/notifications.py

@@ -0,0 +1,49 @@
+"""Async mirror of NotificationService."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..client import AsyncHttpClient
+from ..types import NotificationChannel
+from ..notifications import _to_channel
+
+
+class AsyncNotificationService:
+    def __init__(self, client: AsyncHttpClient):
+        self._client = client
+
+    async def list(self) -> list[NotificationChannel]:
+        data = await self._client.get("/v1/notifications/channels")
+        return [_to_channel(ch) for ch in data]
+
+    async def create(
+        self,
+        channel_type: str,
+        destination: str,
+        events: list[str] | None = None,
+        min_severity: str = "warning",
+    ) -> NotificationChannel:
+        body: dict[str, Any] = {
+            "channel_type": channel_type,
+            "destination": destination,
+            "min_severity": min_severity,
+        }
+        if events:
+            body["events"] = events
+        return _to_channel(await self._client.post("/v1/notifications/channels", json=body))
+
+    async def send_verification_code(self, channel_id: str) -> dict[str, Any]:
+        return await self._client.post(f"/v1/notifications/channels/{channel_id}/send-code")
+
+    async def verify(self, channel_id: str, code: str) -> dict[str, Any]:
+        return await self._client.post(
+            f"/v1/notifications/channels/{channel_id}/verify",
+            json={"code": code},
+        )
+
+    async def test(self, channel_id: str) -> dict[str, Any]:
+        return await self._client.post(f"/v1/notifications/channels/{channel_id}/test")
+
+    async def delete(self, channel_id: str) -> dict[str, Any]:
+        return await self._client.delete(f"/v1/notifications/channels/{channel_id}")