getstack 0.19.0__tar.gz → 1.0.0__tar.gz

{getstack-0.19.0 → getstack-1.0.0}/.gitignore

@@ -31,8 +31,13 @@ Thumbs.db
 
 # Next.js
 .next/
+.next-*/
 out/
 
+# Local package-manager cache and temporary preview helpers
+/.pnpm-store/
+/.tmp-*
+
 # MCP publisher
 mcp-publisher.exe
 .mcpregistry_*
@@ -74,3 +79,13 @@ docs/yc-q18/
 docs/yc-application-session-preface.md
 *-YC.md
 *-yc.md
+
+# Design handoff packages (kept local, never committed)
+STACK website redesign*.zip
+
+# Benchmark working files: harvested environments and interim runs. The
+# published artifacts live in docs/benchmarks/.
+scratchpad/
+
+# Local venv for the AgentDojo benchmark harness (never commit)
+.venv-agentdojo/

{getstack-0.19.0 → getstack-1.0.0}/CLAUDE.md

@@ -14,7 +14,7 @@ Published to PyPI as `getstack`. Not a workspace member of the main monorepo
   credentials, drop-offs (+ expire), skills, identity, audit, notifications
   (+ update), security-events, proxy, scan, usage, intents, missions,
   evidence-packs, llm gateway, inbound-webhooks, partner, **team**,
-  **delivery_methods**, **detector_config**.
+  **delivery_methods**, **detector_config**, **authority**.
 - **Offline / customer-managed crypto** (the JS headline features):
   `verify_passport_offline` (`sdk-python/src/getstack/verify_offline.py` —
   pyjwt/EdDSA, jwks_url OR public_jwk), `verify_passport_header`, and
@@ -45,6 +45,7 @@ hit `/v1/services/connected` and `/v1/services/{id}/disconnect`. Notification
 
 - Package metadata: `sdk-python/pyproject.toml`
 - Module entry: `sdk-python/src/getstack/`
+- Authority lifecycle (sync + async): `sdk-python/src/getstack/authority.py`, `sdk-python/src/getstack/_async/authority.py`
 - User-facing quickstart + examples: `sdk-python/README.md`
 - License: `sdk-python/LICENSE`
 

{getstack-0.19.0 → getstack-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: getstack
-Version: 0.19.0
+Version: 1.0.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.19.0 → getstack-1.0.0}/pyproject.toml

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

{getstack-0.19.0 → getstack-1.0.0}/src/getstack/__init__.py

@@ -66,6 +66,9 @@ from .llm import LlmService
 from .team import TeamService
 from .delivery_methods import DeliveryMethodService
 from .detector_config import DetectorConfigService
+from .pii_config import PiiConfigService
+from .authority import AuthorityService
+from ._async.authority import AsyncAuthorityService
 from .passport_session import PassportSession
 from .types import (
     Agent,
@@ -87,6 +90,12 @@ from .types import (
     IdentityClaim,
     IdentitySettings,
     VerificationSession,
+    SetServiceRequirementInput,
+    ServiceRequirement,
+    ReplaceServiceRequirementResult,
+    AuthorityReference,
+    PassportStackClaims,
+    VerifiedPassportClaims,
 )
 from .errors import (
     StackError,
@@ -167,10 +176,19 @@ __all__ = [
     "IdentityClaim",
     "IdentitySettings",
     "VerificationSession",
+    "SetServiceRequirementInput",
+    "ServiceRequirement",
+    "ReplaceServiceRequirementResult",
+    "AuthorityReference",
+    "PassportStackClaims",
+    "VerifiedPassportClaims",
     # Service classes (for typing / direct construction)
     "TeamService",
     "DeliveryMethodService",
     "DetectorConfigService",
+    "PiiConfigService",
+    "AuthorityService",
+    "AsyncAuthorityService",
     # Offline / customer-managed crypto (parity with the JS SDK)
     "verify_passport_offline",
     "verify_passport_header",
@@ -249,6 +267,8 @@ class Stack:
         self.team = TeamService(self._client)
         self.delivery_methods = DeliveryMethodService(self._client)
         self.detector_config = DetectorConfigService(self._client)
+        self.pii_config = PiiConfigService(self._client)
+        self.authority = AuthorityService(self._client)
 
     def issue_passport(
         self,
@@ -258,6 +278,7 @@ class Stack:
         intents: list[dict[str, Any]] | None = None,
         ttl_seconds: int | None = None,
         accountability_mode: str | None = None,
+        authority_binding_ids: list[str] | None = None,
         **kwargs: Any,
     ) -> PassportSession:
         """Phase 5.2.6 — issue a passport and return a PassportSession
@@ -274,6 +295,7 @@ class Stack:
         if intents is not None: issue_input["intents"] = intents
         if ttl_seconds is not None: issue_input["ttl_seconds"] = ttl_seconds
         if accountability_mode is not None: issue_input["accountability_mode"] = accountability_mode
+        if authority_binding_ids is not None: issue_input["authority_binding_ids"] = authority_binding_ids
         issued = self._client.post("/v1/passports/issue", json=issue_input)
         return PassportSession(self._client, issued, issue_input)
 
@@ -396,6 +418,8 @@ class AsyncStack:
         from ._async.team import AsyncTeamService
         from ._async.delivery_methods import AsyncDeliveryMethodService
         from ._async.detector_config import AsyncDetectorConfigService
+        from ._async.pii_config import AsyncPiiConfigService
+        from ._async.authority import AsyncAuthorityService
         from ._async.passport_session import AsyncPassportSession
 
         self.agents = AsyncAgentService(self._client)
@@ -422,6 +446,8 @@ class AsyncStack:
         self.team = AsyncTeamService(self._client)
         self.delivery_methods = AsyncDeliveryMethodService(self._client)
         self.detector_config = AsyncDetectorConfigService(self._client)
+        self.pii_config = AsyncPiiConfigService(self._client)
+        self.authority = AsyncAuthorityService(self._client)
         # Stash for issue_passport() — Python doesn't easily expose the
         # class binding without re-importing inside the method body.
         self._AsyncPassportSession = AsyncPassportSession
@@ -434,6 +460,7 @@ class AsyncStack:
         intents: list[dict[str, Any]] | None = None,
         ttl_seconds: int | None = None,
         accountability_mode: str | None = None,
+        authority_binding_ids: list[str] | None = None,
         **kwargs: Any,
     ):
         """Phase 5.2.6 — async passport issue + session wrapper."""
@@ -442,6 +469,7 @@ class AsyncStack:
         if intents is not None: issue_input["intents"] = intents
         if ttl_seconds is not None: issue_input["ttl_seconds"] = ttl_seconds
         if accountability_mode is not None: issue_input["accountability_mode"] = accountability_mode
+        if authority_binding_ids is not None: issue_input["authority_binding_ids"] = authority_binding_ids
         issued = await self._client.post("/v1/passports/issue", json=issue_input)
         return self._AsyncPassportSession(self._client, issued, issue_input)
 

getstack-1.0.0/src/getstack/_async/authority.py

@@ -0,0 +1,269 @@
+"""Async authority principal, proof, binding, receiver, and evidence APIs."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..authority import _idempotency_headers, _version_params
+from ..client import AsyncHttpClient
+
+
+class AsyncAuthorityService:
+    """Async mirror of :class:`getstack.authority.AuthorityService`."""
+
+    def __init__(self, client: AsyncHttpClient):
+        self._client = client
+
+    async def create_enterprise_oidc_request(
+        self, *, idempotency_key: str, **input: Any
+    ) -> dict[str, Any]:
+        """Create a pending request and return the human approval URL."""
+        return await self._client.post(
+            "/v1/authority/enterprise-oidc/requests", json=input,
+            extra_headers=_idempotency_headers(idempotency_key),
+        )
+
+    async def get_enterprise_oidc_request(self, request_id: str) -> dict[str, Any]:
+        return await self._client.get(
+            f"/v1/authority/enterprise-oidc/requests/{request_id}"
+        )
+
+    async def create_principal(self, *, idempotency_key: str, **input: Any) -> dict[str, Any]:
+        data = await self._client.post(
+            "/v1/authority/principals", json=input,
+            extra_headers=_idempotency_headers(idempotency_key),
+        )
+        return data["principal"]
+
+    async def list_principals(self) -> list[dict[str, Any]]:
+        return (await self._client.get("/v1/authority/principals"))["principals"]
+
+    async def get_principal(self, principal_id: str) -> dict[str, Any]:
+        return (await self._client.get(f"/v1/authority/principals/{principal_id}"))["principal"]
+
+    async def archive_principal(
+        self, principal_id: str, *, reason_code: str, idempotency_key: str
+    ) -> dict[str, Any]:
+        data = await self._client.post(
+            f"/v1/authority/principals/{principal_id}/archive",
+            json={"reason_code": reason_code},
+            extra_headers=_idempotency_headers(idempotency_key),
+        )
+        return data["principal"]
+
+    async def erase_principal(
+        self, principal_id: str, *, idempotency_key: str
+    ) -> dict[str, Any]:
+        data = await self._client.post(
+            f"/v1/authority/principals/{principal_id}/erase", json={},
+            extra_headers=_idempotency_headers(idempotency_key),
+        )
+        return data["tombstone"]
+
+    async def import_proof(self, *, idempotency_key: str, **input: Any) -> dict[str, Any]:
+        data = await self._client.post(
+            "/v1/authority/proofs/import", json=input,
+            extra_headers=_idempotency_headers(idempotency_key),
+        )
+        return data["proof"]
+
+    async def create_proof_collection_session(
+        self, *, idempotency_key: str, **input: Any
+    ) -> dict[str, Any]:
+        data = await self._client.post(
+            "/v1/authority/proof-collection-sessions", json=input,
+            extra_headers=_idempotency_headers(idempotency_key),
+        )
+        return data["session"]
+
+    async def get_proof_collection_session(self, session_id: str) -> dict[str, Any]:
+        data = await self._client.get(f"/v1/authority/proof-collection-sessions/{session_id}")
+        return data["session"]
+
+    async def list_proofs(self) -> list[dict[str, Any]]:
+        return (await self._client.get("/v1/authority/proofs"))["proofs"]
+
+    async def get_proof(
+        self, proof_id: str, *, version: int | None = None
+    ) -> dict[str, Any]:
+        data = await self._client.get(
+            f"/v1/authority/proofs/{proof_id}", params=_version_params(version)
+        )
+        return data["proof"]
+
+    async def revoke_proof(
+        self, proof_id: str, *, reason_code: str, idempotency_key: str
+    ) -> dict[str, Any]:
+        data = await self._client.post(
+            f"/v1/authority/proofs/{proof_id}/revoke",
+            json={"reason_code": reason_code},
+            extra_headers=_idempotency_headers(idempotency_key),
+        )
+        return data["proof"]
+
+    async def erase_proof(self, proof_id: str, *, idempotency_key: str) -> dict[str, Any]:
+        data = await self._client.post(
+            f"/v1/authority/proofs/{proof_id}/erase", json={},
+            extra_headers=_idempotency_headers(idempotency_key),
+        )
+        return data["proof"]
+
+    async def create_binding(self, *, idempotency_key: str, **input: Any) -> dict[str, Any]:
+        data = await self._client.post(
+            "/v1/authority/bindings", json=input,
+            extra_headers=_idempotency_headers(idempotency_key),
+        )
+        return data["binding"]
+
+    async def list_bindings(self) -> list[dict[str, Any]]:
+        return (await self._client.get("/v1/authority/bindings"))["bindings"]
+
+    async def get_binding(
+        self, binding_id: str, *, version: int | None = None
+    ) -> dict[str, Any]:
+        data = await self._client.get(
+            f"/v1/authority/bindings/{binding_id}", params=_version_params(version)
+        )
+        return data["binding"]
+
+    async def create_approval_requests(
+        self, binding_id: str, *, idempotency_key: str, **input: Any
+    ) -> list[dict[str, Any]]:
+        data = await self._client.post(
+            f"/v1/authority/bindings/{binding_id}/approval-requests", json=input,
+            extra_headers=_idempotency_headers(idempotency_key),
+        )
+        return data["approval_requests"]
+
+    async def list_approval_requests(self, binding_id: str) -> list[dict[str, Any]]:
+        data = await self._client.get(f"/v1/authority/bindings/{binding_id}/approval-requests")
+        return data["approval_requests"]
+
+    async def activate_binding(
+        self, binding_id: str, *, idempotency_key: str, version: int | None = None
+    ) -> dict[str, Any]:
+        data = await self._client.request(
+            "POST", f"/v1/authority/bindings/{binding_id}/activate", json={},
+            params=_version_params(version),
+            extra_headers=_idempotency_headers(idempotency_key),
+        )
+        return data["binding"]
+
+    async def delegate_binding(
+        self, binding_id: str, *, idempotency_key: str, **input: Any
+    ) -> dict[str, Any]:
+        data = await self._client.post(
+            f"/v1/authority/bindings/{binding_id}/delegate", json=input,
+            extra_headers=_idempotency_headers(idempotency_key),
+        )
+        return data["binding"]
+
+    async def revoke_binding(
+        self, binding_id: str, *, reason_code: str, idempotency_key: str
+    ) -> dict[str, Any]:
+        data = await self._client.post(
+            f"/v1/authority/bindings/{binding_id}/revoke",
+            json={"reason_code": reason_code},
+            extra_headers=_idempotency_headers(idempotency_key),
+        )
+        return data["binding"]
+
+    async def erase_binding(
+        self, binding_id: str, *, idempotency_key: str
+    ) -> dict[str, Any]:
+        data = await self._client.post(
+            f"/v1/authority/bindings/{binding_id}/erase", json={},
+            extra_headers=_idempotency_headers(idempotency_key),
+        )
+        return data["tombstone"]
+
+    async def create_receiver(self, *, idempotency_key: str, **input: Any) -> dict[str, Any]:
+        data = await self._client.post(
+            "/v1/authority/receivers", json=input,
+            extra_headers=_idempotency_headers(idempotency_key),
+        )
+        return data["receiver"]
+
+    async def list_receivers(self) -> list[dict[str, Any]]:
+        return (await self._client.get("/v1/authority/receivers"))["receivers"]
+
+    async def get_receiver(self, receiver_id: str) -> dict[str, Any]:
+        return (await self._client.get(f"/v1/authority/receivers/{receiver_id}"))["receiver"]
+
+    async def create_receiver_verification_challenge(
+        self, receiver_id: str, *, idempotency_key: str
+    ) -> dict[str, Any]:
+        data = await self._client.post(
+            f"/v1/authority/receivers/{receiver_id}/verification-challenges", json={},
+            extra_headers=_idempotency_headers(idempotency_key),
+        )
+        return data["challenge"]
+
+    async def verify_receiver(
+        self, receiver_id: str, *, idempotency_key: str
+    ) -> dict[str, Any]:
+        data = await self._client.post(
+            f"/v1/authority/receivers/{receiver_id}/verify", json={},
+            extra_headers=_idempotency_headers(idempotency_key),
+        )
+        return data["receiver"]
+
+    async def add_receiver_key(
+        self, receiver_id: str, *, idempotency_key: str, **input: Any
+    ) -> dict[str, Any]:
+        data = await self._client.post(
+            f"/v1/authority/receivers/{receiver_id}/keys", json=input,
+            extra_headers=_idempotency_headers(idempotency_key),
+        )
+        return data["key"]
+
+    async def revoke_receiver_key(
+        self, receiver_id: str, key_id: str, *, reason_code: str, idempotency_key: str
+    ) -> dict[str, Any]:
+        data = await self._client.post(
+            f"/v1/authority/receivers/{receiver_id}/keys/{key_id}/revoke",
+            json={"reason_code": reason_code},
+            extra_headers=_idempotency_headers(idempotency_key),
+        )
+        return data["key"]
+
+    async def create_profile_version(
+        self, *, idempotency_key: str, **input: Any
+    ) -> dict[str, Any]:
+        data = await self._client.post(
+            "/v1/authority/profile-versions", json=input,
+            extra_headers=_idempotency_headers(idempotency_key),
+        )
+        return data["profile"]
+
+    async def activate_profile_version(
+        self, profile_id: str, *, profile_kind: str, idempotency_key: str
+    ) -> dict[str, Any]:
+        data = await self._client.post(
+            f"/v1/authority/profile-versions/{profile_id}/activate",
+            json={"profile_kind": profile_kind},
+            extra_headers=_idempotency_headers(idempotency_key),
+        )
+        return data["profile"]
+
+    async def list_uses(self) -> list[dict[str, Any]]:
+        return (await self._client.get("/v1/authority/uses"))["uses"]
+
+    async def get_use(self, use_id: str) -> dict[str, Any]:
+        return (await self._client.get(f"/v1/authority/uses/{use_id}"))["use"]
+
+    async def list_presentations(self) -> list[dict[str, Any]]:
+        return (await self._client.get("/v1/authority/presentations"))["presentations"]
+
+    async def get_presentation(self, presentation_id: str) -> dict[str, Any]:
+        data = await self._client.get(f"/v1/authority/presentations/{presentation_id}")
+        return data["presentation"]
+
+    async def erase_presentation(
+        self, presentation_id: str, *, idempotency_key: str
+    ) -> dict[str, Any]:
+        data = await self._client.post(
+            f"/v1/authority/presentations/{presentation_id}/erase", json={},
+            extra_headers=_idempotency_headers(idempotency_key),
+        )
+        return data["tombstone"]

getstack-1.0.0/src/getstack/_async/delivery_methods.py

@@ -0,0 +1,85 @@
+"""Notification delivery methods (async parity with the JS SDK's
+DeliveryMethodService).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..client import AsyncHttpClient
+
+
+class AsyncDeliveryMethodService:
+    def __init__(self, client: AsyncHttpClient):
+        self._client = client
+
+    async def add(
+        self,
+        kind: str,
+        destination: str,
+        governance_approval_id: str | None = None,
+        **fields: Any,
+    ) -> dict[str, Any]:
+        body: dict[str, Any] = {
+            "channel_type": kind,
+            "destination": destination,
+            **fields,
+        }
+        headers = self._approval_headers(governance_approval_id)
+        return await self._client.post(
+            "/v1/notifications/destinations", json=body, extra_headers=headers
+        )
+
+    async def list(self) -> list[dict[str, Any]]:
+        return await self._client.get("/v1/notifications/destinations")
+
+    async def delete(
+        self, destination_id: str, governance_approval_id: str | None = None
+    ) -> dict[str, Any]:
+        return await self._client.delete(
+            f"/v1/notifications/destinations/{destination_id}",
+            extra_headers=self._approval_headers(governance_approval_id),
+        )
+
+    async def rotate_secret(
+        self, destination_id: str, governance_approval_id: str | None = None
+    ) -> dict[str, Any]:
+        """Rotate a webhook secret. The replacement is returned once in this response."""
+        return await self._client.post(
+            f"/v1/notifications/destinations/{destination_id}/rotate-secret",
+            extra_headers=self._approval_headers(governance_approval_id),
+        )
+
+    async def send_verification_code(
+        self, destination_id: str, governance_approval_id: str | None = None
+    ) -> dict[str, Any]:
+        return await self._client.post(
+            f"/v1/notifications/destinations/{destination_id}/send-code",
+            extra_headers=self._approval_headers(governance_approval_id),
+        )
+
+    async def verify(
+        self,
+        destination_id: str,
+        code: str,
+        governance_approval_id: str | None = None,
+    ) -> dict[str, Any]:
+        return await self._client.post(
+            f"/v1/notifications/destinations/{destination_id}/verify",
+            json={"code": code},
+            extra_headers=self._approval_headers(governance_approval_id),
+        )
+
+    async def test(
+        self, destination_id: str, governance_approval_id: str | None = None
+    ) -> dict[str, Any]:
+        return await self._client.post(
+            f"/v1/notifications/destinations/{destination_id}/test",
+            extra_headers=self._approval_headers(governance_approval_id),
+        )
+
+    @staticmethod
+    def _approval_headers(governance_approval_id: str | None) -> dict[str, str] | None:
+        if not governance_approval_id:
+            return None
+        return {"X-Governance-Approval": governance_approval_id}

{getstack-0.19.0 → getstack-1.0.0}/src/getstack/_async/dropoffs.py

@@ -30,10 +30,22 @@ class AsyncDropoffService:
             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]:
+    async def deposit(
+        self,
+        dropoff_id: str,
+        data: dict[str, Any],
+        agent_id: str,
+        passport_jti: str | None = None,
+        mission_id: str | None = None,
+    ) -> dict[str, Any]:
+        body: dict[str, Any] = {"agent_id": agent_id, "payload": data}
+        if passport_jti is not None:
+            body["passport_jti"] = passport_jti
+        if mission_id is not None:
+            body["mission_id"] = mission_id
         return await self._client.post(
             f"/v1/dropoffs/{dropoff_id}/deposit",
-            json={"agent_id": agent_id, "payload": data},
+            json=body,
         )
 
     async def collect(self, dropoff_id: str, agent_id: str) -> dict[str, Any]:

{getstack-0.19.0 → getstack-1.0.0}/src/getstack/_async/evidence_packs.py

@@ -1,9 +1,10 @@
-"""Evidence packs — export, get, list (async mirror of EvidencePacksService)."""
+"""Evidence packs — export, get, download, list."""
 
 from __future__ import annotations
 
 import json
 from typing import Any
+from urllib.parse import quote
 
 from ..client import AsyncHttpClient
 
@@ -33,7 +34,15 @@ class AsyncEvidencePacksService:
         return result
 
     async def get(self, pack_id: str) -> dict[str, Any]:
-        return await self._client.request("GET", f"/v1/evidence-packs/{pack_id}")
+        return await self._client.request(
+            "GET", f"/v1/evidence-packs/{quote(pack_id, safe='')}"
+        )
+
+    async def download(self, pack_id: str) -> bytes:
+        """Fetch the exact stored final manifest bytes."""
+        return await self._client.request_bytes(
+            "GET", f"/v1/evidence-packs/{quote(pack_id, safe='')}/download"
+        )
 
     async def list(self, *, scope: str | None = None) -> dict[str, Any]:
         path = "/v1/evidence-packs"

{getstack-0.19.0 → getstack-1.0.0}/src/getstack/_async/identity.py

@@ -3,9 +3,18 @@
 from __future__ import annotations
 
 from typing import Any
+from urllib.parse import quote
 
 from ..client import AsyncHttpClient
-from ..types import IdentityProvider, IdentityClaim, IdentitySettings, VerificationSession
+from ..types import (
+    IdentityProvider,
+    IdentityClaim,
+    IdentitySettings,
+    VerificationSession,
+    SetServiceRequirementInput,
+    ServiceRequirement,
+    ReplaceServiceRequirementResult,
+)
 from ..identity import _to_provider, _to_claim
 
 
@@ -85,11 +94,27 @@ class AsyncIdentityService:
     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 get_service_requirements(self, service_id: str) -> list[ServiceRequirement]:
+        return await self._client.get(f"/v1/services/{quote(service_id, safe='')}/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)
+    async def set_service_requirement(self, service_id: str, **kwargs: Any) -> ServiceRequirement:
+        return await self._client.post(
+            f"/v1/services/{quote(service_id, safe='')}/requirements",
+            json=kwargs,
+        )
+
+    async def replace_service_requirement(
+        self,
+        service_id: str,
+        requirement: SetServiceRequirementInput | None,
+    ) -> ReplaceServiceRequirementResult:
+        return await self._client.put(
+            f"/v1/services/{quote(service_id, safe='')}/requirements",
+            json={"requirement": requirement},
+        )
 
     async def delete_service_requirement(self, service_id: str, requirement_id: str) -> None:
-        await self._client.delete(f"/v1/services/{service_id}/requirements/{requirement_id}")
+        await self._client.delete(
+            f"/v1/services/{quote(service_id, safe='')}/requirements/"
+            f"{quote(requirement_id, safe='')}"
+        )