replylayer 0.17.0__tar.gz → 0.21.0__tar.gz

{replylayer-0.17.0 → replylayer-0.21.0}/.gitignore

@@ -52,3 +52,7 @@ plans/fault-briefings/
 # under audits/ — these are signed-verdict-anchored evidence per
 # plans/granite-guardian-failover-saturation-stress-test.md §11.
 !audits/**/*.log
+uat-grading-results*.json
+
+# Scanner eval run outputs (corpora are tracked, results are not)
+packages/scanner/src/eval/*-results.json

{replylayer-0.17.0 → replylayer-0.21.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: replylayer
-Version: 0.17.0
+Version: 0.21.0
 Summary: Official Python SDK for ReplyLayer — email for AI agents
 License-Expression: MIT
 Keywords: agent,ai,email,mailbox,replylayer,sdk,webhook
@@ -126,7 +126,7 @@ contract — read it before relying on retries:
 | `rl.recipients` | `create`, `list`, `delete`, `resend` |
 | `rl.suppressions` | `list`, `delete` |
 | `rl.api_keys` | `create`, `list`, `revoke`, `rotate`* |
-| `rl.account` | `get_usage` |
+| `rl.account` | `get_usage`, `get_quota`, `get_link_scanning_status`, `enable_link_scanning` |
 | `rl.health` | `check` |
 
 *`api_keys.rotate()` revokes the calling API key and returns a new one. After calling it, this SDK instance's key is invalidated — create a new `ReplyLayer` instance with the returned key.
@@ -152,7 +152,7 @@ The send/reply/draft-send response carries two additive, nullable keys that expl
 By default `drafts.send()`, `messages.send()`, and `messages.reply()` return only once the scanner verdict is known, with `scan` and `hold_context` inline. Pass `async_dispatch=True` to `drafts.send()` to send the `Prefer: respond-async` hint. **The hint is advisory** — the server returns a `202 AsyncSendAck` only when `OUTBOUND_ASYNC_DISPATCH_ENABLED` is on; otherwise it ignores the hint and returns a normal `SendMessageResponse`. **Always branch on the result**: `result["status"] == "queued_for_dispatch"` ⇒ `AsyncSendAck`, otherwise `SendMessageResponse`. Poll `messages.get(message_id)` (or handle the lifecycle webhook) until `state` is terminal. Attachment-bearing drafts fail closed on the async path (`400 ATTACHMENTS_REQUIRE_SYNC_SEND`). (`messages.wait()` is a mailbox long-poll for new *inbound* mail, not a way to observe a specific message by ID.)
 
 The send endpoint raises `ReplyLayerError` with distinct `.code` values on 409:
-- `DRAFT_REJECTED_BY_RESCAN` — send-time scan flipped the verdict to `block`/`quarantine`. The draft stays in `draft` state; edit the body and retry. `err.details` carries `scan` and, when a policy/HITL decision drove the hold, `hold_context`.
+- `DRAFT_REJECTED_BY_RESCAN` — send-time scan flipped the verdict to `block`/`quarantine`. The draft stays in `draft` state; edit the body and retry. `err.details` carries `scan`, `releasable` (`True` for a `quarantine` hold the customer can release via `POST /v1/drafts/:id/release-and-send`, `False` for a terminal `block`), and, when a policy/HITL decision drove the hold, `hold_context`.
 - `DRAFT_ALREADY_SENT` — the draft was already sent (race or retry after success).
 
 ```python
@@ -426,6 +426,23 @@ Webhook deliveries are deduped server-side to at most one per `(account, mailbox
 
 The MCP tool `list_allowlist_blocked_attempts` exposes the same view to agents — read-only by design. There is no dismiss-attempt tool (the containment boundary would be moot if an agent could clear its own rejection history).
 
+## Malicious link scanning (URL reputation)
+
+Malicious link scanning checks inbound links against Google Web Risk (only SHA-256 hash-prefixes are sent — full URLs never leave the platform). It is off by default and opt-in per account. Enabling it is an **admin action** (it turns on an account-wide sub-processor data flow), so agent-scoped keys can read status but not enable it (they raise `ForbiddenError`).
+
+Pass the version you are acknowledging explicitly; the SDK does not auto-fetch it, so the consent is recorded against a version your code chose:
+
+```python
+status = rl.account.get_link_scanning_status()
+# {"active", "accepted_version", "current_version", "privacy_ok"}
+
+if not status["active"] and status["privacy_ok"]:
+    res = rl.account.enable_link_scanning(accept_web_risk_version=status["current_version"])
+    # res["url_reputation"]["active"] is True; res["disclosure"]["notice"] / ["advisory_url"]
+```
+
+If `privacy_ok` is `False` the account's accepted privacy policy predates the disclosed sub-processor — re-accept the current Privacy Policy first (`enable_link_scanning` would otherwise raise a `409 PRIVACY_VERSION_TOO_OLD`). The async client exposes the same methods (`await rl.account.get_link_scanning_status()` / `await rl.account.enable_link_scanning(...)`).
+
 ## Mailbox identifiers
 
 Every SDK method that takes a `mailbox_id` argument accepts **either the mailbox's UUID or its name**. The server resolves names against the authenticated account's active mailboxes. `rl.messages.list("support-bot")` and `rl.messages.list("a1b2-…")` are equivalent.

{replylayer-0.17.0 → replylayer-0.21.0}/README.md

@@ -109,7 +109,7 @@ contract — read it before relying on retries:
 | `rl.recipients` | `create`, `list`, `delete`, `resend` |
 | `rl.suppressions` | `list`, `delete` |
 | `rl.api_keys` | `create`, `list`, `revoke`, `rotate`* |
-| `rl.account` | `get_usage` |
+| `rl.account` | `get_usage`, `get_quota`, `get_link_scanning_status`, `enable_link_scanning` |
 | `rl.health` | `check` |
 
 *`api_keys.rotate()` revokes the calling API key and returns a new one. After calling it, this SDK instance's key is invalidated — create a new `ReplyLayer` instance with the returned key.
@@ -135,7 +135,7 @@ The send/reply/draft-send response carries two additive, nullable keys that expl
 By default `drafts.send()`, `messages.send()`, and `messages.reply()` return only once the scanner verdict is known, with `scan` and `hold_context` inline. Pass `async_dispatch=True` to `drafts.send()` to send the `Prefer: respond-async` hint. **The hint is advisory** — the server returns a `202 AsyncSendAck` only when `OUTBOUND_ASYNC_DISPATCH_ENABLED` is on; otherwise it ignores the hint and returns a normal `SendMessageResponse`. **Always branch on the result**: `result["status"] == "queued_for_dispatch"` ⇒ `AsyncSendAck`, otherwise `SendMessageResponse`. Poll `messages.get(message_id)` (or handle the lifecycle webhook) until `state` is terminal. Attachment-bearing drafts fail closed on the async path (`400 ATTACHMENTS_REQUIRE_SYNC_SEND`). (`messages.wait()` is a mailbox long-poll for new *inbound* mail, not a way to observe a specific message by ID.)
 
 The send endpoint raises `ReplyLayerError` with distinct `.code` values on 409:
-- `DRAFT_REJECTED_BY_RESCAN` — send-time scan flipped the verdict to `block`/`quarantine`. The draft stays in `draft` state; edit the body and retry. `err.details` carries `scan` and, when a policy/HITL decision drove the hold, `hold_context`.
+- `DRAFT_REJECTED_BY_RESCAN` — send-time scan flipped the verdict to `block`/`quarantine`. The draft stays in `draft` state; edit the body and retry. `err.details` carries `scan`, `releasable` (`True` for a `quarantine` hold the customer can release via `POST /v1/drafts/:id/release-and-send`, `False` for a terminal `block`), and, when a policy/HITL decision drove the hold, `hold_context`.
 - `DRAFT_ALREADY_SENT` — the draft was already sent (race or retry after success).
 
 ```python
@@ -409,6 +409,23 @@ Webhook deliveries are deduped server-side to at most one per `(account, mailbox
 
 The MCP tool `list_allowlist_blocked_attempts` exposes the same view to agents — read-only by design. There is no dismiss-attempt tool (the containment boundary would be moot if an agent could clear its own rejection history).
 
+## Malicious link scanning (URL reputation)
+
+Malicious link scanning checks inbound links against Google Web Risk (only SHA-256 hash-prefixes are sent — full URLs never leave the platform). It is off by default and opt-in per account. Enabling it is an **admin action** (it turns on an account-wide sub-processor data flow), so agent-scoped keys can read status but not enable it (they raise `ForbiddenError`).
+
+Pass the version you are acknowledging explicitly; the SDK does not auto-fetch it, so the consent is recorded against a version your code chose:
+
+```python
+status = rl.account.get_link_scanning_status()
+# {"active", "accepted_version", "current_version", "privacy_ok"}
+
+if not status["active"] and status["privacy_ok"]:
+    res = rl.account.enable_link_scanning(accept_web_risk_version=status["current_version"])
+    # res["url_reputation"]["active"] is True; res["disclosure"]["notice"] / ["advisory_url"]
+```
+
+If `privacy_ok` is `False` the account's accepted privacy policy predates the disclosed sub-processor — re-accept the current Privacy Policy first (`enable_link_scanning` would otherwise raise a `409 PRIVACY_VERSION_TOO_OLD`). The async client exposes the same methods (`await rl.account.get_link_scanning_status()` / `await rl.account.enable_link_scanning(...)`).
+
 ## Mailbox identifiers
 
 Every SDK method that takes a `mailbox_id` argument accepts **either the mailbox's UUID or its name**. The server resolves names against the authenticated account's active mailboxes. `rl.messages.list("support-bot")` and `rl.messages.list("a1b2-…")` are equivalent.

{replylayer-0.17.0 → replylayer-0.21.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "replylayer"
-version = "0.17.0"
+version = "0.21.0"
 description = "Official Python SDK for ReplyLayer — email for AI agents"
 readme = "README.md"
 license = "MIT"

{replylayer-0.17.0 → replylayer-0.21.0}/replylayer/__init__.py

@@ -1,5 +1,6 @@
 from ._client import ReplyLayer, AsyncReplyLayer
 from ._http import RetryInfo
+from .resources.messages import IdempotencyReplayResult
 from .resources.webhooks import verify_webhook_signature
 from .errors import (
     ReplyLayerError,
@@ -12,8 +13,16 @@ from .errors import (
     # Migration 040 — scheduled-send error surface.
     SchedulingError,
     TimezoneRequiredError,
+    # Governed Email-Effect Contract v1 (Track 2) — strict-outcome errors.
+    EmailEffectError,
+    EmailEffectRejectedError,
+    EmailEffectHeldError,
+    EmailEffectRetryableError,
 )
 from .types import (
+    # Message delete response (0.20.0).
+    DeleteMessageResponse,
+    ReportResponse,
     # WS1 — star response types (0.16.0).
     MessageStarResponse,
     ThreadStarResponse,
@@ -57,6 +66,13 @@ from .types import (
     WebRiskLearnMore,
     WebRiskWarning,
     WebRiskThreatType,
+    LinkScanningStatus,
+    EnableLinkScanningResponse,
+    EnableLinkScanningDisclosure,
+    AgentSafetyContext,
+    # Governed Email-Effect Contract v1 (Track 2).
+    EmailEffect,
+    EffectStatus,
     MessageReceivedSafetySignal,
     MessageReceivedWebhookPayload,
     # PR 6 — HITL review queue webhook payload types.
@@ -76,14 +92,19 @@ from .types import (
     ScannerPolicy,
 )
 
-__version__ = "0.17.0"
+__version__ = "0.21.0"
 
 __all__ = [
+    # Message delete response (0.20.0).
+    "DeleteMessageResponse",
+    "ReportResponse",
     # WS1 — star response types (0.16.0).
     "MessageStarResponse",
     "ThreadStarResponse",
     # WS6-SDK — async optimistic-ack (0.16.0).
     "AsyncSendAck",
+    # Track 1 — non-throwing idempotency replay probe result.
+    "IdempotencyReplayResult",
     "ReplyLayer",
     "AsyncReplyLayer",
     "RetryInfo",
@@ -98,6 +119,13 @@ __all__ = [
     # Migration 040 — scheduled-send.
     "SchedulingError",
     "TimezoneRequiredError",
+    # Governed Email-Effect Contract v1 (Track 2).
+    "EmailEffectError",
+    "EmailEffectRejectedError",
+    "EmailEffectHeldError",
+    "EmailEffectRetryableError",
+    "EmailEffect",
+    "EffectStatus",
     "WebhookSummary",
     "WebhookDeliverySummary",
     "WebhookDeliveryStatus",
@@ -132,6 +160,10 @@ __all__ = [
     "WebRiskLearnMore",
     "WebRiskWarning",
     "WebRiskThreatType",
+    "LinkScanningStatus",
+    "EnableLinkScanningResponse",
+    "EnableLinkScanningDisclosure",
+    "AgentSafetyContext",
     "MessageReceivedSafetySignal",
     "MessageReceivedWebhookPayload",
     # PR 6 — HITL review queue.

{replylayer-0.17.0 → replylayer-0.21.0}/replylayer/_client.py

@@ -36,6 +36,7 @@ class ReplyLayer:
         timeout: float = 30.0,
         max_retry_after_seconds: float = _MAX_RETRY_AFTER_SECONDS,
         on_retry: OnRetry | None = None,
+        strict_outcome: bool = False,
     ) -> None:
         if not api_key:
             raise ReplyLayerError(
@@ -43,6 +44,12 @@ class ReplyLayer:
                 "api_key is required. Get yours at https://app.replylayer.ai/connect",
             )
 
+        # Governed Email-Effect Contract v1 (Track 2) — client-default for the
+        # `Prefer: outcome=strict` opt-in. When True, messages.send / .reply
+        # request a non-2xx (503/422/409) for a held/blocked outcome, raising the
+        # matching EmailEffectError subclass instead of resolving a 200. Default
+        # False is byte-identical to today (200 with `email_effect` in the body,
+        # no throw). Override per-call via `messages.send(strict_outcome=...)`.
         self._http = SyncHttpClient(
             api_key=api_key,
             base_url=base_url.rstrip("/"),
@@ -50,6 +57,7 @@ class ReplyLayer:
             timeout=timeout,
             max_retry_after_seconds=max_retry_after_seconds,
             on_retry=on_retry,
+            strict_outcome=strict_outcome,
         )
 
         self.domains = SyncDomains(self._http)
@@ -87,6 +95,7 @@ class AsyncReplyLayer:
         timeout: float = 30.0,
         max_retry_after_seconds: float = _MAX_RETRY_AFTER_SECONDS,
         on_retry: OnRetry | None = None,
+        strict_outcome: bool = False,
     ) -> None:
         if not api_key:
             raise ReplyLayerError(
@@ -94,6 +103,7 @@ class AsyncReplyLayer:
                 "api_key is required. Get yours at https://app.replylayer.ai/connect",
             )
 
+        # Governed Email-Effect Contract v1 (Track 2) — see ReplyLayer above.
         self._http = AsyncHttpClient(
             api_key=api_key,
             base_url=base_url.rstrip("/"),
@@ -101,6 +111,7 @@ class AsyncReplyLayer:
             timeout=timeout,
             max_retry_after_seconds=max_retry_after_seconds,
             on_retry=on_retry,
+            strict_outcome=strict_outcome,
         )
 
         self.domains = AsyncDomains(self._http)

{replylayer-0.17.0 → replylayer-0.21.0}/replylayer/_http.py

@@ -9,7 +9,7 @@ import httpx
 
 from .errors import ReplyLayerError, error_from_response
 
-_VERSION = "0.17.0"
+_VERSION = "0.21.0"
 _USER_AGENT = f"replylayer-sdk-py/{_VERSION}"
 _PROTECTED_HEADER_KEYS = frozenset({"authorization", "content-type", "user-agent"})
 
@@ -47,6 +47,7 @@ class SyncHttpClient:
         timeout: float,
         max_retry_after_seconds: float = _MAX_RETRY_AFTER_SECONDS,
         on_retry: OnRetry | None = None,
+        strict_outcome: bool = False,
     ) -> None:
         self._api_key = api_key
         self._base_url = base_url
@@ -54,6 +55,10 @@ class SyncHttpClient:
         self._timeout = timeout
         self._max_retry_after_seconds = max_retry_after_seconds
         self._on_retry = on_retry
+        # Governed Email-Effect Contract v1 (Track 2) — client default for the
+        # `Prefer: outcome=strict` opt-in. Read by SyncMessages/AsyncMessages
+        # send/reply as the fallback when the per-call `strict_outcome` is None.
+        self._strict_outcome = strict_outcome
         self._client = httpx.Client(timeout=timeout)
 
     def close(self) -> None:
@@ -194,6 +199,7 @@ class AsyncHttpClient:
         timeout: float,
         max_retry_after_seconds: float = _MAX_RETRY_AFTER_SECONDS,
         on_retry: OnRetry | None = None,
+        strict_outcome: bool = False,
     ) -> None:
         self._api_key = api_key
         self._base_url = base_url
@@ -201,6 +207,8 @@ class AsyncHttpClient:
         self._timeout = timeout
         self._max_retry_after_seconds = max_retry_after_seconds
         self._on_retry = on_retry
+        # Governed Email-Effect Contract v1 (Track 2) — see SyncHttpClient.
+        self._strict_outcome = strict_outcome
         self._client = httpx.AsyncClient(timeout=timeout)
 
     async def aclose(self) -> None:

{replylayer-0.17.0 → replylayer-0.21.0}/replylayer/errors.py

@@ -113,6 +113,92 @@ class TimezoneRequiredError(SchedulingError):
         )
 
 
+# Governed Email-Effect Contract v1 (Track 2) — strict-outcome opt-in errors.
+#
+# Raised ONLY when the caller opted in via `strict_outcome=True`
+# (Prefer: outcome=strict) AND the server maps a non-delivered terminal/held
+# outcome to a non-2xx. The error body carries the full governed payload
+# (`message_id`, `status`, `scan`, `hold_context`, `email_effect`) in
+# `details`, so a caller can branch retry-vs-edit-vs-escalate from the throw.
+#
+# Default (no `strict_outcome`) is byte-identical to today: the send/reply path
+# returns HTTP 200 with `email_effect` in the body and NONE of these is raised.
+#
+# Subclass of ReplyLayerError so generic catches still work; isinstance
+# EmailEffectError narrows to the strict-outcome family. Status-code → subclass:
+#   503 EMAIL_EFFECT_HELD_INFRA → EmailEffectRetryableError (carries retry_after)
+#   422 EMAIL_EFFECT_REJECTED   → EmailEffectRejectedError  (terminal content block)
+#   409 EMAIL_EFFECT_HELD       → EmailEffectHeldError      (releasable hold)
+# The factory recognizes the family by the body carrying `details.email_effect`
+# (mirroring the TS SDK), not by the `code` string.
+
+
+class EmailEffectError(ReplyLayerError):
+    """Base for the strict-outcome (``Prefer: outcome=strict``) error family.
+
+    ``email_effect`` is the parsed ``details.email_effect`` block (the governed
+    discriminator + booleans); ``scan`` is the parsed ``details.scan`` summary.
+    Both may be None if the server omitted them.
+    """
+
+    def __init__(
+        self,
+        status_code: int,
+        code: str,
+        message: str,
+        details: dict[str, Any] | None = None,
+    ) -> None:
+        super().__init__(status_code, code, message, details)
+        d = details or {}
+        self.email_effect: dict[str, Any] | None = d.get("email_effect")
+        self.scan: dict[str, Any] | None = d.get("scan")
+
+
+class EmailEffectRejectedError(EmailEffectError):
+    """422 EMAIL_EFFECT_REJECTED — a genuine terminal content rejection.
+
+    ``email_effect.effect_status == 'blocked'`` (terminal=True). The agent's
+    correct action is edit-and-resend or escalate — NEVER retry the same body.
+    """
+
+    def __init__(self, code: str, message: str, details: dict[str, Any] | None = None) -> None:
+        super().__init__(422, code, message, details)
+
+
+class EmailEffectHeldError(EmailEffectError):
+    """409 EMAIL_EFFECT_HELD — accepted into governance, releasable.
+
+    ``email_effect.effect_status == 'held_for_review'`` (releasable=True). The
+    send was quarantined / queued for human review — report "awaiting approval",
+    do not treat as a content error to fix by editing.
+    """
+
+    def __init__(self, code: str, message: str, details: dict[str, Any] | None = None) -> None:
+        super().__init__(409, code, message, details)
+
+
+class EmailEffectRetryableError(EmailEffectError):
+    """503 EMAIL_EFFECT_HELD_INFRA — a transient infrastructure hold.
+
+    ``email_effect.effect_status == 'held_infrastructure'`` (retryable=True): an
+    ``inference_error`` with NO genuine model judgment, so the content was never
+    judged. The agent's correct action is retry-later (back off on repeated
+    503s). ``retry_after`` mirrors the ``Retry-After`` header (None on absent /
+    non-numeric), reusing the same null-on-NaN parse as RateLimitError.
+    """
+
+    def __init__(
+        self,
+        code: str,
+        message: str,
+        headers: dict[str, str],
+        details: dict[str, Any] | None = None,
+    ) -> None:
+        super().__init__(503, code, message, details)
+        ra = headers.get("retry-after")
+        self.retry_after: int | None = int(ra) if ra and ra.isdigit() else None
+
+
 def error_from_response(
     status: int,
     body: dict[str, Any],
@@ -139,6 +225,24 @@ def error_from_response(
     if code in _SCHEDULING_REASON_CODES:
         return SchedulingError(status, code, message, details)
 
+    # Governed Email-Effect Contract v1 (Track 2) — strict-outcome opt-in.
+    # Precedence-first BEFORE the generic status switch so a 503 becomes an
+    # EmailEffectRetryableError (not a generic ReplyLayerError), a 422 an
+    # EmailEffectRejectedError (not a plain ValidationError), and a 409 an
+    # EmailEffectHeldError — so `isinstance(err, EmailEffectError)` works
+    # uniformly across statuses. Gated on the body carrying `email_effect`
+    # (present ONLY when the request opted in AND the server applied the strict
+    # mapping), mirroring the TS SDK's `details?.email_effect` gate — robust to
+    # the exact `code` string. Any other status falls through to the generic
+    # switch unchanged.
+    if isinstance(details, dict) and details.get("email_effect") is not None:
+        if status == 422:
+            return EmailEffectRejectedError(code, message, details)
+        if status == 409:
+            return EmailEffectHeldError(code, message, details)
+        if status == 503:
+            return EmailEffectRetryableError(code, message, headers, details)
+
     if status == 401:
         return AuthenticationError(code, message, details)
     if status == 403:

replylayer-0.21.0/replylayer/resources/account.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .._http import AsyncHttpClient, SyncHttpClient
+from ..errors import ReplyLayerError
+from ..types import (
+    EnableLinkScanningResponse,
+    LinkScanningStatus,
+    QuotaResponse,
+    UsageResponse,
+)
+
+# Raised when the deployed API predates the malicious-link-scanning surface and
+# omits the url_reputation block from GET /v1/auth/me. Mirrors the TS SDK / CLI
+# clear "API outdated" error instead of leaking a raw KeyError.
+_LINK_SCANNING_UNSUPPORTED_MSG = (
+    "Server did not return link-scanning status; the API may be outdated."
+)
+
+
+class SyncAccount:
+    def __init__(self, http: SyncHttpClient) -> None:
+        self._http = http
+
+    def get_usage(self) -> UsageResponse:
+        return self._http.request("GET", "/v1/accounts/usage")
+
+    def get_quota(self) -> QuotaResponse:
+        return self._http.request("GET", "/v1/accounts/quota")
+
+    def get_link_scanning_status(self) -> LinkScanningStatus:
+        """Malicious link scanning (URL reputation, Google Web Risk) status.
+
+        Reads the ``url_reputation`` block off GET /v1/auth/me. Works with any key.
+        """
+        me = self._http.request("GET", "/v1/auth/me")
+        if "url_reputation" not in me:
+            raise ReplyLayerError(0, "LINK_SCANNING_UNSUPPORTED", _LINK_SCANNING_UNSUPPORTED_MSG)
+        return me["url_reputation"]
+
+    def enable_link_scanning(self, accept_web_risk_version: str) -> EnableLinkScanningResponse:
+        """Enable malicious link scanning.
+
+        Pass the disclaimer version you are acknowledging (from
+        ``get_link_scanning_status()["current_version"]``) — the consent is explicit.
+        Requires an admin key or session (agent keys get 403). The response includes
+        the disclosure you accepted.
+        """
+        return self._http.request(
+            "POST",
+            "/v1/accounts/url-reputation",
+            body={"accept_web_risk_version": accept_web_risk_version},
+        )
+
+    def export(self) -> dict[str, Any]:
+        """GDPR Art. 20 data portability export — the full account-data object."""
+        return self._http.request("GET", "/v1/accounts/export")
+
+
+class AsyncAccount:
+    def __init__(self, http: AsyncHttpClient) -> None:
+        self._http = http
+
+    async def get_usage(self) -> UsageResponse:
+        return await self._http.request("GET", "/v1/accounts/usage")
+
+    async def get_quota(self) -> QuotaResponse:
+        return await self._http.request("GET", "/v1/accounts/quota")
+
+    async def get_link_scanning_status(self) -> LinkScanningStatus:
+        """Malicious link scanning (URL reputation, Google Web Risk) status.
+
+        Reads the ``url_reputation`` block off GET /v1/auth/me. Works with any key.
+        """
+        me = await self._http.request("GET", "/v1/auth/me")
+        if "url_reputation" not in me:
+            raise ReplyLayerError(0, "LINK_SCANNING_UNSUPPORTED", _LINK_SCANNING_UNSUPPORTED_MSG)
+        return me["url_reputation"]
+
+    async def enable_link_scanning(self, accept_web_risk_version: str) -> EnableLinkScanningResponse:
+        """Enable malicious link scanning.
+
+        Pass the disclaimer version you are acknowledging (from
+        ``get_link_scanning_status()["current_version"]``) — the consent is explicit.
+        Requires an admin key or session (agent keys get 403). The response includes
+        the disclosure you accepted.
+        """
+        return await self._http.request(
+            "POST",
+            "/v1/accounts/url-reputation",
+            body={"accept_web_risk_version": accept_web_risk_version},
+        )
+
+    async def export(self) -> dict[str, Any]:
+        """GDPR Art. 20 data portability export — the full account-data object."""
+        return await self._http.request("GET", "/v1/accounts/export")