e2a 2.4.0__tar.gz → 3.0.0__tar.gz

{e2a-2.4.0 → e2a-3.0.0}/.gitignore

@@ -39,3 +39,6 @@ sdks/python/.pytest_cache/
 
 # Docs
 docs/originals/
+
+# Go coverage profile (make cover)
+cover.out

{e2a-2.4.0 → e2a-3.0.0}/CHANGELOG.md

@@ -1,5 +1,60 @@
 # Changelog
 
+## 3.0.0
+
+Breaking redesign. The SDK is now a namespaced, **async-only** `E2AClient`
+wrapping a generated client over the agent-scoped `/v1` API surface, with a
+typed error hierarchy, automatic retries + idempotency, and async
+auto-pagination.
+
+### Changed
+- **Namespaced, async-only surface.** Resources are grouped under the client:
+  `client.agents`, `client.messages`, `client.conversations`, `client.domains`,
+  `client.events`, `client.webhooks`, `client.account`. Per-agent methods take
+  the agent `address` as the first argument
+  (`await client.messages.send(address, {...})`,
+  `await client.messages.list(address).to_list(limit=...)`,
+  `await client.messages.get(address, id)`,
+  `await client.messages.reply(address, id, {...})`). Use the client as an async
+  context manager (`async with E2AClient() as client:`).
+- **Webhook verification.** Verify and decode a delivery with the standalone
+  `construct_event(raw_body, signature_header, secret)`, which checks the
+  `X-E2A-Signature` header and returns a typed event (raising
+  `E2AWebhookSignatureError` on a bad signature). Per-webhook `whsec_…` secrets,
+  Stripe-style.
+- **Typed errors.** Failures raise `E2AError` subclasses (`E2ANotFoundError`,
+  `E2AConflictError`, `E2AValidationError`, `E2ARateLimitError`,
+  `E2AWebhookSignatureError`, …) carrying `.code`, `.status`, `.request_id`, and
+  `.retryable`.
+
+### Removed
+- The flat methods `send` / `reply` / `get_messages` / `get_message` and the
+  per-call `agent_email` inference. Pass the agent `address` explicitly.
+- The lower-level `E2AApi` class.
+- The synchronous client — the SDK is async-only.
+- `InboundEmail` / `AsyncInboundEmail` and the `parse_webhook` / `parse` +
+  `verify_signature()` flow. Replaced by `construct_event`. There is no
+  unverified-email type and no field-access gating.
+
+## 2.5.0
+
+### Added
+- Generated types for the per-user resource-limits primitive that
+  shipped with #158: `LimitsInfo`, `LimitsCaps`, `LimitsUsage`. These
+  describe the response shape of `GET /api/v1/users/me/limits`, which
+  the hosted dashboard uses to render the upgrade affordance and the
+  "you've used X of Y" surface. The high-level `E2AClient` doesn't
+  yet expose a typed helper for this endpoint — it's surfaced as a
+  dashboard-only concern today, and SDK consumers querying their own
+  usage should call `/agents` / `/messages` directly. The types are
+  emitted so anyone consuming the raw OpenAPI generation has the
+  shapes available.
+
+### Notes
+- No runtime client behavior changed in this release. If you're not
+  using the limits primitive (self-host deployments without a paid
+  tier), 2.5.0 is functionally identical to 2.4.0.
+
 ## 2.4.0
 
 ### Added

e2a-3.0.0/PKG-INFO

@@ -0,0 +1,178 @@
+Metadata-Version: 2.4
+Name: e2a
+Version: 3.0.0
+Summary: Python SDK for the e2a protocol — email-to-agent authentication
+Project-URL: Homepage, https://e2a.dev
+Project-URL: Repository, https://github.com/Mnexa-AI/e2a
+Project-URL: Documentation, https://e2a.dev
+Author-email: Mnexa AI <josh@mnexa.ai>
+License-Expression: Apache-2.0
+Keywords: agent,authentication,e2a,email,webhook
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+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: Topic :: Communications :: Email
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.24
+Requires-Dist: pydantic<3,>=2.12
+Requires-Dist: python-dateutil>=2.8
+Requires-Dist: typing-extensions>=4.7
+Requires-Dist: urllib3>=1.25
+Provides-Extra: dev
+Requires-Dist: anyio[trio]; extra == 'dev'
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: pytest-httpx; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Requires-Dist: pyyaml>=6; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Provides-Extra: ws
+Requires-Dist: websockets>=14; extra == 'ws'
+Description-Content-Type: text/markdown
+
+# e2a Python SDK
+
+Async Python SDK for [e2a](https://e2a.dev) — email for AI agents.
+
+## Install
+
+```bash
+pip install e2a          # add the [ws] extra for client.listen(): pip install "e2a[ws]"
+```
+
+The SDK major version tracks the SDK package's own breaking changes and is
+independent of the API version path (`/v1`): SDK 3.x targets the e2a v1 API.
+
+## Upgrading from 2.x to 3.0
+
+3.0 is a breaking redesign. The SDK now wraps a generated `/v1` client behind a
+namespaced, **async-only** surface, with a typed error hierarchy, automatic
+retries + idempotency, and async auto-pagination.
+
+- **Async-only, namespaced.** The sync client and the flat methods are gone.
+  `client.get_messages()` → `client.messages.list(address)`,
+  `client.get_message(id)` → `client.messages.get(address, id)`,
+  `client.send(...)` → `client.messages.send(address, body)`. Per-agent calls
+  take an explicit `address`.
+- **Webhook verification.** `client.parse` / `client.parse_webhook` /
+  `InboundEmail` are removed. Verify and parse a delivery with the standalone
+  `construct_event(raw_body, header, secret)`, which returns a typed
+  `WebhookEvent`. Signatures are per-webhook (`whsec_…`), Stripe-style.
+- **Typed errors.** Failures raise `E2AError` subclasses (`E2ANotFoundError`,
+  `E2AConflictError`, `E2AValidationError`, `E2ARateLimitError`, …) carrying
+  `.code`, `.status`, `.request_id`, and `.retryable`.
+
+## Quick Start
+
+```python
+import asyncio
+from e2a.v1 import E2AClient
+
+async def main():
+    # reads E2A_API_KEY; base_url defaults to https://api.e2a.dev
+    async with E2AClient() as client:
+        address = "my-agent@agents.e2a.dev"
+
+        # List endpoints return an AutoPager: async-iterate, or collect with a limit.
+        async for m in client.messages.list(address, status="unread"):
+            email = await client.messages.get(address, m.message_id)
+            print(email.subject)
+            await client.messages.reply(address, m.message_id, {"body": "Got it!"})
+
+asyncio.run(main())
+```
+
+### Send mail
+
+```python
+await client.messages.send(address, {
+    "to": ["alice@example.com"],
+    "subject": "Hello",
+    "body": "Hi from my agent!",
+    "html_body": "<p>Hi!</p>",
+})
+```
+
+The mail-sending writes (`send` / `reply` / `forward` / `approve`) auto-mint an
+`Idempotency-Key` and reuse it across retries, so a network blip can't
+double-send. Pass a stable key to also survive a process restart:
+
+```python
+await client.messages.send(address, body, idempotency_key=derive_from(event))
+```
+
+Request bodies accept a plain `dict` (shown above) or the generated model
+(`from e2a.v1 import SendEmailRequest`).
+
+### Verify a webhook
+
+Each subscription is signed with its own `whsec_…` secret. `construct_event`
+verifies the `X-E2A-Signature` header (replay-protected) and returns a typed
+event. **Pass the raw request body** — re-serialized JSON won't match.
+
+```python
+from e2a.v1 import construct_event, E2AWebhookSignatureError
+
+@app.post("/webhook")
+async def webhook(request):
+    try:
+        event = construct_event(await request.body(), request.headers["X-E2A-Signature"], SECRET)
+    except E2AWebhookSignatureError:
+        return Response(status_code=400)
+    if event.type == "email.received":
+        ...  # event.data carries the message payload
+    return {"ok": True}
+```
+
+During a rotation you can pass a list of secrets — accepted if any matches:
+`construct_event(body, header, [old_secret, new_secret])`.
+
+## Resources
+
+`client.agents`, `client.messages`, `client.conversations`, `client.domains`,
+`client.events`, `client.webhooks`, `client.account` (with
+`client.account.suppressions`), plus `await client.info()`. Each method maps to
+a `/v1` operation; per-agent methods take the agent `address` first.
+
+### `E2AClient(api_key=None, *, base_url=None, max_retries=2, max_elapsed_ms=None)`
+
+`api_key` falls back to `E2A_API_KEY`; `base_url` to `E2A_BASE_URL` then
+`https://api.e2a.dev`. Use it as an async context manager (or call
+`await client.aclose()`) to close the underlying HTTP connections.
+
+### Errors
+
+Every failure raises an `E2AError` (or subclass) with `.code`, `.status`,
+`.request_id`, `.retryable`: `E2AAuthError` (401), `E2APermissionError` (403),
+`E2ANotFoundError` (404), `E2AConflictError` (409), `E2AValidationError` (422),
+`E2AIdempotencyError`, `E2ARateLimitError` (429), `E2AServerError` (5xx),
+`E2AConnectionError` (no response), `E2AWebhookSignatureError`.
+
+> e2a hides the existence of agents you don't own — `agents.get` of an unknown
+> address raises `E2APermissionError` (403), not `E2ANotFoundError`.
+
+### Pagination
+
+List methods return an `AutoPager` — async-iterate it, or use
+`await pager.to_list(limit=N)` (the limit is required, to bound memory) or
+`await pager.for_each(fn)` (return `False` to stop early).
+
+## WebSocket (real-time delivery for local agents)
+
+```python
+async for notif in client.listen("bot@agents.e2a.dev"):  # falls back to E2A_AGENT_EMAIL
+    email = await client.messages.get(notif.recipient, notif.message_id)
+```
+
+`client.listen(address)` returns a `WSStream` (async-iterable of
+`WSNotification`) that reconnects with exponential backoff. Requires the `[ws]`
+extra (`pip install "e2a[ws]"`).
+
+## License
+
+Apache-2.0 — see [LICENSE](https://github.com/Mnexa-AI/e2a/blob/main/LICENSE) and [NOTICE](https://github.com/Mnexa-AI/e2a/blob/main/NOTICE) in the upstream repo.

e2a-3.0.0/README.md

@@ -0,0 +1,141 @@
+# e2a Python SDK
+
+Async Python SDK for [e2a](https://e2a.dev) — email for AI agents.
+
+## Install
+
+```bash
+pip install e2a          # add the [ws] extra for client.listen(): pip install "e2a[ws]"
+```
+
+The SDK major version tracks the SDK package's own breaking changes and is
+independent of the API version path (`/v1`): SDK 3.x targets the e2a v1 API.
+
+## Upgrading from 2.x to 3.0
+
+3.0 is a breaking redesign. The SDK now wraps a generated `/v1` client behind a
+namespaced, **async-only** surface, with a typed error hierarchy, automatic
+retries + idempotency, and async auto-pagination.
+
+- **Async-only, namespaced.** The sync client and the flat methods are gone.
+  `client.get_messages()` → `client.messages.list(address)`,
+  `client.get_message(id)` → `client.messages.get(address, id)`,
+  `client.send(...)` → `client.messages.send(address, body)`. Per-agent calls
+  take an explicit `address`.
+- **Webhook verification.** `client.parse` / `client.parse_webhook` /
+  `InboundEmail` are removed. Verify and parse a delivery with the standalone
+  `construct_event(raw_body, header, secret)`, which returns a typed
+  `WebhookEvent`. Signatures are per-webhook (`whsec_…`), Stripe-style.
+- **Typed errors.** Failures raise `E2AError` subclasses (`E2ANotFoundError`,
+  `E2AConflictError`, `E2AValidationError`, `E2ARateLimitError`, …) carrying
+  `.code`, `.status`, `.request_id`, and `.retryable`.
+
+## Quick Start
+
+```python
+import asyncio
+from e2a.v1 import E2AClient
+
+async def main():
+    # reads E2A_API_KEY; base_url defaults to https://api.e2a.dev
+    async with E2AClient() as client:
+        address = "my-agent@agents.e2a.dev"
+
+        # List endpoints return an AutoPager: async-iterate, or collect with a limit.
+        async for m in client.messages.list(address, status="unread"):
+            email = await client.messages.get(address, m.message_id)
+            print(email.subject)
+            await client.messages.reply(address, m.message_id, {"body": "Got it!"})
+
+asyncio.run(main())
+```
+
+### Send mail
+
+```python
+await client.messages.send(address, {
+    "to": ["alice@example.com"],
+    "subject": "Hello",
+    "body": "Hi from my agent!",
+    "html_body": "<p>Hi!</p>",
+})
+```
+
+The mail-sending writes (`send` / `reply` / `forward` / `approve`) auto-mint an
+`Idempotency-Key` and reuse it across retries, so a network blip can't
+double-send. Pass a stable key to also survive a process restart:
+
+```python
+await client.messages.send(address, body, idempotency_key=derive_from(event))
+```
+
+Request bodies accept a plain `dict` (shown above) or the generated model
+(`from e2a.v1 import SendEmailRequest`).
+
+### Verify a webhook
+
+Each subscription is signed with its own `whsec_…` secret. `construct_event`
+verifies the `X-E2A-Signature` header (replay-protected) and returns a typed
+event. **Pass the raw request body** — re-serialized JSON won't match.
+
+```python
+from e2a.v1 import construct_event, E2AWebhookSignatureError
+
+@app.post("/webhook")
+async def webhook(request):
+    try:
+        event = construct_event(await request.body(), request.headers["X-E2A-Signature"], SECRET)
+    except E2AWebhookSignatureError:
+        return Response(status_code=400)
+    if event.type == "email.received":
+        ...  # event.data carries the message payload
+    return {"ok": True}
+```
+
+During a rotation you can pass a list of secrets — accepted if any matches:
+`construct_event(body, header, [old_secret, new_secret])`.
+
+## Resources
+
+`client.agents`, `client.messages`, `client.conversations`, `client.domains`,
+`client.events`, `client.webhooks`, `client.account` (with
+`client.account.suppressions`), plus `await client.info()`. Each method maps to
+a `/v1` operation; per-agent methods take the agent `address` first.
+
+### `E2AClient(api_key=None, *, base_url=None, max_retries=2, max_elapsed_ms=None)`
+
+`api_key` falls back to `E2A_API_KEY`; `base_url` to `E2A_BASE_URL` then
+`https://api.e2a.dev`. Use it as an async context manager (or call
+`await client.aclose()`) to close the underlying HTTP connections.
+
+### Errors
+
+Every failure raises an `E2AError` (or subclass) with `.code`, `.status`,
+`.request_id`, `.retryable`: `E2AAuthError` (401), `E2APermissionError` (403),
+`E2ANotFoundError` (404), `E2AConflictError` (409), `E2AValidationError` (422),
+`E2AIdempotencyError`, `E2ARateLimitError` (429), `E2AServerError` (5xx),
+`E2AConnectionError` (no response), `E2AWebhookSignatureError`.
+
+> e2a hides the existence of agents you don't own — `agents.get` of an unknown
+> address raises `E2APermissionError` (403), not `E2ANotFoundError`.
+
+### Pagination
+
+List methods return an `AutoPager` — async-iterate it, or use
+`await pager.to_list(limit=N)` (the limit is required, to bound memory) or
+`await pager.for_each(fn)` (return `False` to stop early).
+
+## WebSocket (real-time delivery for local agents)
+
+```python
+async for notif in client.listen("bot@agents.e2a.dev"):  # falls back to E2A_AGENT_EMAIL
+    email = await client.messages.get(notif.recipient, notif.message_id)
+```
+
+`client.listen(address)` returns a `WSStream` (async-iterable of
+`WSNotification`) that reconnects with exponential backoff. Requires the `[ws]`
+extra (`pip install "e2a[ws]"`).
+
+## License
+
+Apache-2.0 — see [LICENSE](https://github.com/Mnexa-AI/e2a/blob/main/LICENSE) and [NOTICE](https://github.com/Mnexa-AI/e2a/blob/main/NOTICE) in the upstream repo.

{e2a-2.4.0 → e2a-3.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "e2a"
-version = "2.4.0"
+version = "3.0.0"
 description = "Python SDK for the e2a protocol — email-to-agent authentication"
 readme = "README.md"
 license = "Apache-2.0"
@@ -12,7 +12,7 @@ requires-python = ">=3.9"
 authors = [{ name = "Mnexa AI", email = "josh@mnexa.ai" }]
 keywords = ["email", "agent", "authentication", "e2a", "webhook"]
 classifiers = [
-    "Development Status :: 4 - Beta",
+    "Development Status :: 5 - Production/Stable",
     "Intended Audience :: Developers",
     "License :: OSI Approved :: Apache Software License",
     "Programming Language :: Python :: 3",
@@ -23,7 +23,22 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
     "Topic :: Communications :: Email",
 ]
-dependencies = ["httpx>=0.24", "pydantic>=2.12,<3"]
+dependencies = [
+    "httpx>=0.24",
+    "pydantic>=2.12,<3",
+    # Runtime deps of the OpenAPI-Generator /v1 client base (e2a.v1.generated, httpx
+    # library): date parsing, the Retry type in configuration, and Self on the
+    # generated pydantic v2 models.
+    "python-dateutil>=2.8",
+    "urllib3>=1.25",
+    "typing-extensions>=4.7",
+]
+
+[tool.hatch.build.targets.wheel]
+# src layout: ship the e2a package (incl. PEP 561 py.typed markers at every
+# hand-written level, not just the generated sub-package).
+packages = ["src/e2a"]
+artifacts = ["src/e2a/py.typed", "src/e2a/v1/py.typed", "src/e2a/v1/generated/py.typed"]
 
 [project.urls]
 Homepage = "https://e2a.dev"
@@ -32,4 +47,4 @@ Documentation = "https://e2a.dev"
 
 [project.optional-dependencies]
 dev = ["pytest>=7", "pytest-httpx", "anyio[trio]", "pyyaml>=6", "build", "twine"]
-ws = ["websockets>=12"]
+ws = ["websockets>=14"]

e2a-3.0.0/scripts/generate-oag.sh

@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+# Regenerate the Python /v1 client base from the canonical api/openapi.yaml
+# using OpenAPI Generator's `python` generator with the **httpx** library:
+# async-native (matches the async-only Python decision) and httpx-based (the
+# same HTTP client the hand-written layer uses — no second HTTP dependency).
+# Output lands as the package e2a.v1.generated; the hand-written ergonomic layer wraps it.
+# Pinned image tag → reproducible for the drift gate. Run via Docker (no Java).
+#
+# packageName=e2a.v1.generated so the generator's absolute imports (`from
+# e2a.v1.generated ...`) match the package's final location. We generate to a
+# temp dir and copy only the leaf package, so nothing pollutes the source root
+# and the existing e2a/__init__.py and e2a/v1/__init__.py are never touched.
+set -euo pipefail
+ROOT="$(cd "$(dirname "$0")/../../.." && pwd)"
+TMP="$ROOT/sdks/python/.oag-tmp"
+DEST="$ROOT/sdks/python/src/e2a/v1/generated"
+IMG="openapitools/openapi-generator-cli:v7.16.0"
+
+rm -rf "$TMP"
+# Run as the invoking host user (not the container's default root) so the
+# generated files + the .oag-tmp scratch dir are host-user-owned and removable
+# on CI's non-root runner. HOME is a writable path for tools that expect it.
+# (Docker Desktop/macOS maps ownership already, so this is a no-op there but
+# required on Linux CI.)
+docker run --rm --user "$(id -u):$(id -g)" -e HOME=/tmp -v "$ROOT:/work" "$IMG" generate \
+  -i /work/api/openapi.yaml -g python \
+  -o /work/sdks/python/.oag-tmp \
+  --additional-properties=packageName=e2a.v1.generated,library=httpx >/dev/null
+
+rm -rf "$DEST"
+cp -r "$TMP/e2a/v1/generated" "$DEST"
+rm -rf "$TMP"
+
+# Strip the generator's `*_validate_enum` validators so the client tolerates
+# unknown enum values (forward-compat: a new server enum value must not crash a
+# deployed client). Matches the TypeScript SDK's passthrough behavior.
+python3 "$ROOT/sdks/python/scripts/strip-enum-validators.py" "$DEST"
+
+echo "Python /v1 client base regenerated at sdks/python/src/e2a/v1/generated"

e2a-3.0.0/scripts/strip-enum-validators.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""Strip OpenAPI-Generator's `*_validate_enum` pydantic validators from the
+generated models so the client tolerates unknown enum values.
+
+Why: the generator emits, for every enum-typed field, a `@field_validator` that
+raises `ValueError` when the value isn't in a hard-coded set. On a RESPONSE
+field that means the day the server adds a new enum value (a new event `type`,
+`delivery_status`, `inbound_policy`, …) every deployed client crashes while
+deserializing — turning an additive, non-breaking server change into a
+client-breaking one. The TypeScript SDK passes unknown enum values through
+untouched; this makes Python match, keeping enum fields typed as plain strings.
+
+Run as part of generate-oag.sh (so the drift gate's regenerated output matches)
+and idempotently re-runnable on the committed tree. Removes each block of the
+form:
+
+        @field_validator('field')
+        def field_validate_enum(cls, value):
+            \"\"\"Validates the enum\"\"\"
+            if value not in set([...]):
+                raise ValueError(...)
+            return value
+"""
+
+from __future__ import annotations
+
+import glob
+import os
+import re
+import sys
+
+
+def strip_file(path: str) -> bool:
+    with open(path, "r", encoding="utf-8") as f:
+        lines = f.readlines()
+
+    out: list[str] = []
+    i = 0
+    n = len(lines)
+    changed = False
+    decorator = re.compile(r"^\s*@field_validator\(")
+    enum_def = re.compile(r"^\s*def\s+\w+_validate_enum\(")
+    while i < n:
+        line = lines[i]
+        # A `@field_validator(...)` decorator whose method is an enum validator:
+        # drop the decorator(s) + the entire def body. The body runs until the
+        # next non-blank line indented no deeper than the def itself (the next
+        # class member). Consuming by indentation — not by a `return value`
+        # sentinel — correctly handles optional-field validators that early-
+        # return on None before the enum check.
+        if decorator.match(line):
+            j = i + 1
+            while j < n and lines[j].strip().startswith("@"):
+                j += 1
+            if j < n and enum_def.match(lines[j]):
+                def_indent = len(lines[j]) - len(lines[j].lstrip())
+                k = j + 1
+                while k < n:
+                    stripped = lines[k].strip()
+                    if stripped == "":
+                        k += 1
+                        continue
+                    indent = len(lines[k]) - len(lines[k].lstrip())
+                    if indent > def_indent:
+                        k += 1
+                        continue
+                    break
+                i = k
+                changed = True
+                continue
+        out.append(line)
+        i += 1
+
+    if changed:
+        with open(path, "w", encoding="utf-8") as f:
+            f.writelines(out)
+    return changed
+
+
+def main() -> int:
+    root = sys.argv[1] if len(sys.argv) > 1 else os.path.join(
+        os.path.dirname(__file__), "..", "src", "e2a", "v1", "generated"
+    )
+    models = glob.glob(os.path.join(root, "models", "*.py"))
+    touched = sum(1 for p in sorted(models) if strip_file(p))
+    print(f"strip-enum-validators: removed enum validators from {touched} model file(s)")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

e2a-3.0.0/src/e2a/__init__.py

@@ -0,0 +1,52 @@
+# Top-level convenience alias — points to the current stable API version (v1).
+#
+# The pinned contract path is `e2a.v1`:
+#   from e2a.v1 import E2AClient
+#
+# The top-level `e2a` package re-exports that surface for convenience.
+
+from e2a.v1 import (  # noqa: F401
+    AutoPager,
+    E2AAuthError,
+    E2AClient,
+    E2AConflictError,
+    E2AConnectionError,
+    E2AError,
+    E2AIdempotencyError,
+    E2ANotFoundError,
+    E2APermissionError,
+    E2ARateLimitError,
+    E2AServerError,
+    E2AValidationError,
+    E2AWebhookSignatureError,
+    Page,
+    WebhookEvent,
+    WSNotification,
+    WSStream,
+    construct_event,
+    models,
+    verify_webhook_signature,
+)
+
+__all__ = [
+    "E2AClient",
+    "E2AError",
+    "E2AAuthError",
+    "E2APermissionError",
+    "E2ANotFoundError",
+    "E2AConflictError",
+    "E2AValidationError",
+    "E2AIdempotencyError",
+    "E2ARateLimitError",
+    "E2AServerError",
+    "E2AConnectionError",
+    "E2AWebhookSignatureError",
+    "AutoPager",
+    "Page",
+    "verify_webhook_signature",
+    "construct_event",
+    "WebhookEvent",
+    "WSNotification",
+    "WSStream",
+    "models",
+]

e2a-3.0.0/src/e2a/v1/__init__.py

@@ -0,0 +1,71 @@
+"""Public surface of the e2a v1 SDK (async-only).
+
+The canonical request/response types are the OpenAPI-Generator ``generated``
+models; the hand-written ergonomic layer (:class:`E2AClient` + resources, the
+typed error hierarchy, retry/pagination, webhook verification, WS) wraps them.
+The legacy flat/sync ``api`` / ``client`` / ``handler`` surface and the old
+swag-generated Pydantic types have been retired in favour of this.
+"""
+
+# Generated request/response models (the canonical types).
+from e2a.v1.generated import models  # noqa: F401
+from e2a.v1.generated.models import *  # noqa: F401,F403
+
+# High-level async client.
+from e2a.v1.client import E2AClient  # noqa: F401
+
+# Typed error hierarchy.
+from e2a.v1.errors import (  # noqa: F401
+    E2AAuthError,
+    E2AConflictError,
+    E2AConnectionError,
+    E2AError,
+    E2AIdempotencyError,
+    E2ANotFoundError,
+    E2APermissionError,
+    E2ARateLimitError,
+    E2AServerError,
+    E2AValidationError,
+    E2AWebhookSignatureError,
+)
+
+# Auto-pagination.
+from e2a.v1.pagination import AutoPager, Page  # noqa: F401
+
+# Webhook signature verification.
+from e2a.v1.webhook_signature import (  # noqa: F401
+    WebhookEvent,
+    construct_event,
+    verify_webhook_signature,
+)
+
+# Real-time WebSocket stream.
+from e2a.v1.websocket import WSNotification, WSStream  # noqa: F401
+
+__all__ = [
+    "E2AClient",
+    # Errors
+    "E2AError",
+    "E2AAuthError",
+    "E2APermissionError",
+    "E2ANotFoundError",
+    "E2AConflictError",
+    "E2AValidationError",
+    "E2AIdempotencyError",
+    "E2ARateLimitError",
+    "E2AServerError",
+    "E2AConnectionError",
+    "E2AWebhookSignatureError",
+    # Pagination
+    "AutoPager",
+    "Page",
+    # Webhooks
+    "verify_webhook_signature",
+    "construct_event",
+    "WebhookEvent",
+    # WebSocket
+    "WSNotification",
+    "WSStream",
+    # Generated models namespace
+    "models",
+]