islo 0.1.0__tar.gz

islo-0.1.0/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.3
+Name: islo
+Version: 0.1.0
+Summary: Typed Python SDK for the Islo Web API
+Keywords: islo,sdk,openapi,api-client
+Author: Islo Labs
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Dist: httpx>=0.23.0,<0.29.0
+Requires-Dist: pydantic[email]>=2.0.0
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/islo-labs/islo-sdk
+Project-URL: Repository, https://github.com/islo-labs/islo-sdk
+Project-URL: Issues, https://github.com/islo-labs/islo-sdk/issues
+Description-Content-Type: text/markdown
+
+# islo
+
+Typed Python SDK for the [Islo](https://islo.dev) API.
+
+## Install
+
+```sh
+pip install islo
+```
+
+## Usage
+
+```python
+from islo import Islo
+
+client = Islo(api_key="sk-...")
+
+# List sandboxes
+sandboxes = client.sandboxes.list(limit=20)
+
+# Create a sandbox
+from islo.models import SandboxCreate, SandboxSpec
+
+sandbox = client.sandboxes.create(body=SandboxCreate(
+    name="my-sandbox",
+    spec=SandboxSpec(cpu=2, memory=4096),
+))
+
+# Get a sandbox
+sandbox = client.sandboxes.get("my-sandbox")
+
+# Execute a command
+from islo.models import ExecRequest
+
+result = client.sandboxes.exec("my-sandbox", body=ExecRequest(
+    command=["echo", "hello"],
+))
+
+# Delete
+client.sandboxes.delete("my-sandbox")
+```
+
+## Resources
+
+| Resource | Methods |
+|---|---|
+| `client.sandboxes` | `list`, `create`, `get`, `delete`, `stop`, `exec`, `exec_stream`, `promote_cache`, `list_agent_sessions`, `get_agent_session_events`, `list_exec_sessions`, `get_exec_session_logs` |
+| `client.tenants` | `list`, `create`, `get_settings`, `update_settings`, `get_subscription` |
+| `client.users` | `get`, `invite`, `update`, `authorize` |
+| `client.shares` | `list`, `create`, `revoke` |
+| `client.integrations` | `list`, `list_providers`, `get_status`, `disconnect` |
+| `client.usage` | `sandbox_usage`, `summary` |
+| `client.certificate_authority` | `create_certificate`, `get_public_key` |
+
+## Regenerate
+
+```sh
+just sync
+```

islo-0.1.0/README.md

@@ -0,0 +1,59 @@
+# islo
+
+Typed Python SDK for the [Islo](https://islo.dev) API.
+
+## Install
+
+```sh
+pip install islo
+```
+
+## Usage
+
+```python
+from islo import Islo
+
+client = Islo(api_key="sk-...")
+
+# List sandboxes
+sandboxes = client.sandboxes.list(limit=20)
+
+# Create a sandbox
+from islo.models import SandboxCreate, SandboxSpec
+
+sandbox = client.sandboxes.create(body=SandboxCreate(
+    name="my-sandbox",
+    spec=SandboxSpec(cpu=2, memory=4096),
+))
+
+# Get a sandbox
+sandbox = client.sandboxes.get("my-sandbox")
+
+# Execute a command
+from islo.models import ExecRequest
+
+result = client.sandboxes.exec("my-sandbox", body=ExecRequest(
+    command=["echo", "hello"],
+))
+
+# Delete
+client.sandboxes.delete("my-sandbox")
+```
+
+## Resources
+
+| Resource | Methods |
+|---|---|
+| `client.sandboxes` | `list`, `create`, `get`, `delete`, `stop`, `exec`, `exec_stream`, `promote_cache`, `list_agent_sessions`, `get_agent_session_events`, `list_exec_sessions`, `get_exec_session_logs` |
+| `client.tenants` | `list`, `create`, `get_settings`, `update_settings`, `get_subscription` |
+| `client.users` | `get`, `invite`, `update`, `authorize` |
+| `client.shares` | `list`, `create`, `revoke` |
+| `client.integrations` | `list`, `list_providers`, `get_status`, `disconnect` |
+| `client.usage` | `sandbox_usage`, `summary` |
+| `client.certificate_authority` | `create_certificate`, `get_public_key` |
+
+## Regenerate
+
+```sh
+just sync
+```

islo-0.1.0/islo/__init__.py

@@ -0,0 +1,26 @@
+"""Islo Python SDK."""
+
+from islo._client import AsyncIslo, Islo
+from islo._exceptions import (
+    APIStatusError,
+    AuthenticationError,
+    InternalServerError,
+    IsloError,
+    NotFoundError,
+    PermissionDeniedError,
+    RateLimitError,
+    UnprocessableEntityError,
+)
+
+__all__ = [
+    "AsyncIslo",
+    "Islo",
+    "IsloError",
+    "APIStatusError",
+    "AuthenticationError",
+    "PermissionDeniedError",
+    "NotFoundError",
+    "UnprocessableEntityError",
+    "RateLimitError",
+    "InternalServerError",
+]

islo-0.1.0/islo/_api/auth.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from islo._base import AsyncAPIResource, SyncAPIResource
+from islo.models import (
+    TokenRequest,
+    TokenResponse,
+)
+
+
+class Auth(SyncAPIResource):
+    def exchange_token(self, *, body: TokenRequest) -> TokenResponse:
+        """Exchange an access key for a session token."""
+        return self._request("POST", "/auth/token", json_body=body, response_model=TokenResponse)
+
+
+class AsyncAuth(AsyncAPIResource):
+    async def exchange_token(self, *, body: TokenRequest) -> TokenResponse:
+        """Exchange an access key for a session token."""
+        return await self._request("POST", "/auth/token", json_body=body, response_model=TokenResponse)

islo-0.1.0/islo/_api/certificate_authority.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from islo._base import AsyncAPIResource, SyncAPIResource
+from islo.models import (
+    CAPublicKeyResponse,
+    SSHCertificateRequest,
+    SSHCertificateResponse,
+)
+
+
+class CertificateAuthority(SyncAPIResource):
+    def create_certificate(self, *, body: SSHCertificateRequest) -> SSHCertificateResponse:
+        """Issue SSH certificate"""
+        return self._request("POST", "/certificate-authority/", json_body=body, response_model=SSHCertificateResponse)
+
+    def get_public_key(self) -> CAPublicKeyResponse:
+        """Get CA public key"""
+        return self._request("GET", "/certificate-authority/public-key", response_model=CAPublicKeyResponse)
+
+
+class AsyncCertificateAuthority(AsyncAPIResource):
+    async def create_certificate(self, *, body: SSHCertificateRequest) -> SSHCertificateResponse:
+        """Issue SSH certificate"""
+        return await self._request(
+            "POST", "/certificate-authority/", json_body=body, response_model=SSHCertificateResponse
+        )
+
+    async def get_public_key(self) -> CAPublicKeyResponse:
+        """Get CA public key"""
+        return await self._request("GET", "/certificate-authority/public-key", response_model=CAPublicKeyResponse)

islo-0.1.0/islo/_api/integrations.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from typing import Any
+
+from islo._base import AsyncAPIResource, SyncAPIResource
+from islo.models import (
+    IntegrationDetailResponse,
+    IntegrationListResponse,
+    IntegrationProvidersResponse,
+)
+
+
+class Integrations(SyncAPIResource):
+    def list(self) -> IntegrationListResponse:
+        """List User Integrations"""
+        return self._request("GET", "/integrations", response_model=IntegrationListResponse)
+
+    def list_providers(self) -> IntegrationProvidersResponse:
+        """List Providers"""
+        return self._request("GET", "/integrations/providers", response_model=IntegrationProvidersResponse)
+
+    def disconnect(self, provider: str, *, level: str | None = "user") -> Any:
+        """Disconnect Integration"""
+        return self._request("DELETE", f"/integrations/{provider}", params={"level": level})
+
+    def get_status(self, provider: str) -> IntegrationDetailResponse:
+        """Get Integration Status"""
+        return self._request("GET", f"/integrations/{provider}", response_model=IntegrationDetailResponse)
+
+
+class AsyncIntegrations(AsyncAPIResource):
+    async def list(self) -> IntegrationListResponse:
+        """List User Integrations"""
+        return await self._request("GET", "/integrations", response_model=IntegrationListResponse)
+
+    async def list_providers(self) -> IntegrationProvidersResponse:
+        """List Providers"""
+        return await self._request("GET", "/integrations/providers", response_model=IntegrationProvidersResponse)
+
+    async def disconnect(self, provider: str, *, level: str | None = "user") -> Any:
+        """Disconnect Integration"""
+        return await self._request("DELETE", f"/integrations/{provider}", params={"level": level})
+
+    async def get_status(self, provider: str) -> IntegrationDetailResponse:
+        """Get Integration Status"""
+        return await self._request("GET", f"/integrations/{provider}", response_model=IntegrationDetailResponse)

islo-0.1.0/islo/_api/models_.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from islo._base import AsyncAPIResource, SyncAPIResource
+from islo.models import (
+    ModelPricingResponse,
+)
+
+
+class Models(SyncAPIResource):
+    def get_pricing(self) -> ModelPricingResponse:
+        """Get model pricing"""
+        return self._request("GET", "/models/pricing", response_model=ModelPricingResponse)
+
+
+class AsyncModels(AsyncAPIResource):
+    async def get_pricing(self) -> ModelPricingResponse:
+        """Get model pricing"""
+        return await self._request("GET", "/models/pricing", response_model=ModelPricingResponse)

islo-0.1.0/islo/_api/sandboxes.py

@@ -0,0 +1,256 @@
+from __future__ import annotations
+
+from typing import Any
+
+from islo._base import AsyncAPIResource, SyncAPIResource
+from islo.models import (
+    AgentSessionEventResponse,
+    AgentSessionResponse,
+    ExecLogsResponse,
+    ExecRequest,
+    ExecResponse,
+    ExecSessionResponse,
+    PaginatedSandboxResponse,
+    SandboxCreate,
+    SandboxResponse,
+    SyncExecRequest,
+    SyncExecResponse,
+)
+
+
+class Sandboxes(SyncAPIResource):
+    def list(
+        self,
+        *,
+        search: str | None = None,
+        status: str | None = None,
+        date_from: str | None = None,
+        date_to: str | None = None,
+        created_by: str | None = None,
+        limit: int | None = 50,
+        offset: int | None = 0,
+    ) -> PaginatedSandboxResponse:
+        """List sandboxes"""
+        return self._request(
+            "GET",
+            "/sandboxes/",
+            params={
+                "search": search,
+                "status": status,
+                "date_from": date_from,
+                "date_to": date_to,
+                "created_by": created_by,
+                "limit": limit,
+                "offset": offset,
+            },
+            response_model=PaginatedSandboxResponse,
+        )
+
+    def create(self, *, body: SandboxCreate) -> SandboxResponse:
+        """Create sandbox"""
+        return self._request("POST", "/sandboxes/", json_body=body, response_model=SandboxResponse)
+
+    def list_agent_sessions(
+        self, sandbox_id: str, *, since: str | None = None, include_subagents: bool | None = False
+    ) -> list[AgentSessionResponse]:
+        """List agent sessions"""
+        return self._request(
+            "GET",
+            f"/sandboxes/{sandbox_id}/agent-sessions",
+            params={"since": since, "include_subagents": include_subagents},
+        )
+
+    def get_agent_session_events(
+        self,
+        sandbox_id: str,
+        session_name: str,
+        *,
+        session_path: str | None = None,
+        include_descendants: bool | None = True,
+        limit: int | None = 500,
+        offset: int | None = 0,
+        since: str | None = None,
+    ) -> list[AgentSessionEventResponse]:
+        """Get agent session events"""
+        return self._request(
+            "GET",
+            f"/sandboxes/{sandbox_id}/agent-sessions/{session_name}/events",
+            params={
+                "session_path": session_path,
+                "include_descendants": include_descendants,
+                "limit": limit,
+                "offset": offset,
+                "since": since,
+            },
+        )
+
+    def list_exec_sessions(self, sandbox_id: str, *, since: str | None = None) -> list[ExecSessionResponse]:
+        """List exec sessions"""
+        return self._request("GET", f"/sandboxes/{sandbox_id}/exec-sessions", params={"since": since})
+
+    def get_exec_session_asciinema(self, sandbox_id: str, exec_id: str, *, limit: int | None = 2000) -> Any:
+        """Get exec session as asciinema cast"""
+        return self._request(
+            "GET", f"/sandboxes/{sandbox_id}/exec-sessions/{exec_id}/asciinema", params={"limit": limit}
+        )
+
+    def get_exec_session_logs(
+        self, sandbox_id: str, exec_id: str, *, limit: int | None = 2000, since: str | None = None
+    ) -> ExecLogsResponse:
+        """Get exec session logs"""
+        return self._request(
+            "GET",
+            f"/sandboxes/{sandbox_id}/exec-sessions/{exec_id}/logs",
+            params={"limit": limit, "since": since},
+            response_model=ExecLogsResponse,
+        )
+
+    def delete(self, sandbox_name: str) -> Any:
+        """Remove sandbox"""
+        return self._request("DELETE", f"/sandboxes/{sandbox_name}")
+
+    def get(self, sandbox_name: str) -> SandboxResponse:
+        """Get sandbox"""
+        return self._request("GET", f"/sandboxes/{sandbox_name}", response_model=SandboxResponse)
+
+    def exec(self, sandbox_name: str, *, body: ExecRequest) -> ExecResponse:
+        """Execute command"""
+        return self._request("POST", f"/sandboxes/{sandbox_name}/exec", json_body=body, response_model=ExecResponse)
+
+    def exec_stream(self, sandbox_name: str, *, body: ExecRequest) -> Any:
+        """Execute command with streaming"""
+        return self._request("POST", f"/sandboxes/{sandbox_name}/exec/stream", json_body=body)
+
+    def promote_cache(self, sandbox_name: str) -> Any:
+        """Promote cache"""
+        return self._request("POST", f"/sandboxes/{sandbox_name}/promote-cache")
+
+    def stop(self, sandbox_name: str) -> Any:
+        """Stop sandbox"""
+        return self._request("POST", f"/sandboxes/{sandbox_name}/stop")
+
+    def exec_sync(self, sandbox_name: str, *, body: SyncExecRequest) -> SyncExecResponse:
+        """Execute a command synchronously and return stdout/stderr/exit_code."""
+        return self._request(
+            "POST", f"/sandboxes/{sandbox_name}/exec/sync", json_body=body, response_model=SyncExecResponse
+        )
+
+
+class AsyncSandboxes(AsyncAPIResource):
+    async def list(
+        self,
+        *,
+        search: str | None = None,
+        status: str | None = None,
+        date_from: str | None = None,
+        date_to: str | None = None,
+        created_by: str | None = None,
+        limit: int | None = 50,
+        offset: int | None = 0,
+    ) -> PaginatedSandboxResponse:
+        """List sandboxes"""
+        return await self._request(
+            "GET",
+            "/sandboxes/",
+            params={
+                "search": search,
+                "status": status,
+                "date_from": date_from,
+                "date_to": date_to,
+                "created_by": created_by,
+                "limit": limit,
+                "offset": offset,
+            },
+            response_model=PaginatedSandboxResponse,
+        )
+
+    async def create(self, *, body: SandboxCreate) -> SandboxResponse:
+        """Create sandbox"""
+        return await self._request("POST", "/sandboxes/", json_body=body, response_model=SandboxResponse)
+
+    async def list_agent_sessions(
+        self, sandbox_id: str, *, since: str | None = None, include_subagents: bool | None = False
+    ) -> list[AgentSessionResponse]:
+        """List agent sessions"""
+        return await self._request(
+            "GET",
+            f"/sandboxes/{sandbox_id}/agent-sessions",
+            params={"since": since, "include_subagents": include_subagents},
+        )
+
+    async def get_agent_session_events(
+        self,
+        sandbox_id: str,
+        session_name: str,
+        *,
+        session_path: str | None = None,
+        include_descendants: bool | None = True,
+        limit: int | None = 500,
+        offset: int | None = 0,
+        since: str | None = None,
+    ) -> list[AgentSessionEventResponse]:
+        """Get agent session events"""
+        return await self._request(
+            "GET",
+            f"/sandboxes/{sandbox_id}/agent-sessions/{session_name}/events",
+            params={
+                "session_path": session_path,
+                "include_descendants": include_descendants,
+                "limit": limit,
+                "offset": offset,
+                "since": since,
+            },
+        )
+
+    async def list_exec_sessions(self, sandbox_id: str, *, since: str | None = None) -> list[ExecSessionResponse]:
+        """List exec sessions"""
+        return await self._request("GET", f"/sandboxes/{sandbox_id}/exec-sessions", params={"since": since})
+
+    async def get_exec_session_asciinema(self, sandbox_id: str, exec_id: str, *, limit: int | None = 2000) -> Any:
+        """Get exec session as asciinema cast"""
+        return await self._request(
+            "GET", f"/sandboxes/{sandbox_id}/exec-sessions/{exec_id}/asciinema", params={"limit": limit}
+        )
+
+    async def get_exec_session_logs(
+        self, sandbox_id: str, exec_id: str, *, limit: int | None = 2000, since: str | None = None
+    ) -> ExecLogsResponse:
+        """Get exec session logs"""
+        return await self._request(
+            "GET",
+            f"/sandboxes/{sandbox_id}/exec-sessions/{exec_id}/logs",
+            params={"limit": limit, "since": since},
+            response_model=ExecLogsResponse,
+        )
+
+    async def delete(self, sandbox_name: str) -> Any:
+        """Remove sandbox"""
+        return await self._request("DELETE", f"/sandboxes/{sandbox_name}")
+
+    async def get(self, sandbox_name: str) -> SandboxResponse:
+        """Get sandbox"""
+        return await self._request("GET", f"/sandboxes/{sandbox_name}", response_model=SandboxResponse)
+
+    async def exec(self, sandbox_name: str, *, body: ExecRequest) -> ExecResponse:
+        """Execute command"""
+        return await self._request(
+            "POST", f"/sandboxes/{sandbox_name}/exec", json_body=body, response_model=ExecResponse
+        )
+
+    async def exec_stream(self, sandbox_name: str, *, body: ExecRequest) -> Any:
+        """Execute command with streaming"""
+        return await self._request("POST", f"/sandboxes/{sandbox_name}/exec/stream", json_body=body)
+
+    async def promote_cache(self, sandbox_name: str) -> Any:
+        """Promote cache"""
+        return await self._request("POST", f"/sandboxes/{sandbox_name}/promote-cache")
+
+    async def stop(self, sandbox_name: str) -> Any:
+        """Stop sandbox"""
+        return await self._request("POST", f"/sandboxes/{sandbox_name}/stop")
+
+    async def exec_sync(self, sandbox_name: str, *, body: SyncExecRequest) -> SyncExecResponse:
+        """Execute a command synchronously and return stdout/stderr/exit_code."""
+        return await self._request(
+            "POST", f"/sandboxes/{sandbox_name}/exec/sync", json_body=body, response_model=SyncExecResponse
+        )

islo-0.1.0/islo/_api/shares.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from typing import Any
+
+from islo._base import AsyncAPIResource, SyncAPIResource
+from islo.models import (
+    CreateShareRequest,
+    ShareResponse,
+)
+
+
+class Shares(SyncAPIResource):
+    def list(self, sandbox_name: str) -> list[ShareResponse]:
+        """List shares"""
+        return self._request("GET", f"/sandboxes/{sandbox_name}/shares")
+
+    def create(self, sandbox_name: str, *, body: CreateShareRequest) -> ShareResponse:
+        """Create share"""
+        return self._request("POST", f"/sandboxes/{sandbox_name}/shares", json_body=body, response_model=ShareResponse)
+
+    def revoke(self, sandbox_name: str, share_id: str) -> Any:
+        """Revoke share"""
+        return self._request("DELETE", f"/sandboxes/{sandbox_name}/shares/{share_id}")
+
+
+class AsyncShares(AsyncAPIResource):
+    async def list(self, sandbox_name: str) -> list[ShareResponse]:
+        """List shares"""
+        return await self._request("GET", f"/sandboxes/{sandbox_name}/shares")
+
+    async def create(self, sandbox_name: str, *, body: CreateShareRequest) -> ShareResponse:
+        """Create share"""
+        return await self._request(
+            "POST", f"/sandboxes/{sandbox_name}/shares", json_body=body, response_model=ShareResponse
+        )
+
+    async def revoke(self, sandbox_name: str, share_id: str) -> Any:
+        """Revoke share"""
+        return await self._request("DELETE", f"/sandboxes/{sandbox_name}/shares/{share_id}")

islo-0.1.0/islo/_api/tenants.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import Any
+
+from islo._base import AsyncAPIResource, SyncAPIResource
+from islo.models import (
+    CreateTenant,
+    PublicSubscription,
+    PublicTenant,
+    TenantSettingsResponse,
+    TenantSettingsUpdate,
+)
+
+
+class Tenants(SyncAPIResource):
+    def list(self) -> list[PublicTenant]:
+        """Get All Tenants"""
+        return self._request("GET", "/tenants/")
+
+    def create(self, *, body: CreateTenant) -> Any:
+        """Create Tenant"""
+        return self._request("POST", "/tenants/", json_body=body)
+
+    def get_settings(self) -> TenantSettingsResponse:
+        """Get Settings"""
+        return self._request("GET", "/tenants/settings", response_model=TenantSettingsResponse)
+
+    def update_settings(self, *, body: TenantSettingsUpdate) -> TenantSettingsResponse:
+        """Update Settings"""
+        return self._request("PATCH", "/tenants/settings", json_body=body, response_model=TenantSettingsResponse)
+
+    def get_subscription(self) -> PublicSubscription:
+        """Get Subscription"""
+        return self._request("GET", "/tenants/subscription", response_model=PublicSubscription)
+
+
+class AsyncTenants(AsyncAPIResource):
+    async def list(self) -> list[PublicTenant]:
+        """Get All Tenants"""
+        return await self._request("GET", "/tenants/")
+
+    async def create(self, *, body: CreateTenant) -> Any:
+        """Create Tenant"""
+        return await self._request("POST", "/tenants/", json_body=body)
+
+    async def get_settings(self) -> TenantSettingsResponse:
+        """Get Settings"""
+        return await self._request("GET", "/tenants/settings", response_model=TenantSettingsResponse)
+
+    async def update_settings(self, *, body: TenantSettingsUpdate) -> TenantSettingsResponse:
+        """Update Settings"""
+        return await self._request("PATCH", "/tenants/settings", json_body=body, response_model=TenantSettingsResponse)
+
+    async def get_subscription(self) -> PublicSubscription:
+        """Get Subscription"""
+        return await self._request("GET", "/tenants/subscription", response_model=PublicSubscription)

islo-0.1.0/islo/_api/usage.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from islo._base import AsyncAPIResource, SyncAPIResource
+from islo.models import (
+    SandboxUsageDetail,
+    UsageSummary,
+)
+
+
+class Usage(SyncAPIResource):
+    def sandbox_usage(self, *, start: str | None = None, end: str | None = None) -> list[SandboxUsageDetail]:
+        """Get detailed usage per sandbox for the authenticated tenant"""
+        return self._request("GET", "/usage/me/sandboxes", params={"start": start, "end": end})
+
+    def summary(self, *, start: str | None = None, end: str | None = None) -> UsageSummary:
+        """Get usage summary for the authenticated tenant"""
+        return self._request(
+            "GET", "/usage/me/summary", params={"start": start, "end": end}, response_model=UsageSummary
+        )
+
+
+class AsyncUsage(AsyncAPIResource):
+    async def sandbox_usage(self, *, start: str | None = None, end: str | None = None) -> list[SandboxUsageDetail]:
+        """Get detailed usage per sandbox for the authenticated tenant"""
+        return await self._request("GET", "/usage/me/sandboxes", params={"start": start, "end": end})
+
+    async def summary(self, *, start: str | None = None, end: str | None = None) -> UsageSummary:
+        """Get usage summary for the authenticated tenant"""
+        return await self._request(
+            "GET", "/usage/me/summary", params={"start": start, "end": end}, response_model=UsageSummary
+        )