beckn-sdk 1.0.0__tar.gz

beckn_sdk-1.0.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: beckn-sdk
+Version: 1.0.0
+Summary: BeckN Protocol SDK for Python
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"

beckn_sdk-1.0.0/README.md

@@ -0,0 +1,347 @@
+# BeckN Protocol SDK — Python
+
+Python SDK for the BeckN Protocol, implementing the Beckn protocol specification for domain-agnostic digital commerce.
+
+## Installation
+
+```bash
+pip install beckn-sdk
+```
+
+## Quick Start
+
+### Initialize Client
+
+```python
+from beckn import BeckNClient, BeckNClientConfig
+
+client = BeckNClient(BeckNClientConfig(
+    base_url="https://api.beckn.network/v1",
+    api_key="bk_your_api_key_here",
+    timeout=30000,
+))
+```
+
+### Register a BAP
+
+```python
+bap = client.create_bap(BapCreate(
+    id="my-bap-001",
+    name="My Store App",
+    endpoint="https://store.example.com",
+    country="US",
+    lat=40.7128,
+    lon=-74.0060,
+))
+```
+
+### Register a BPP
+
+```python
+bpp = client.create_bpp(BppCreate(
+    id="my-bpp-001",
+    name="My Provider App",
+    endpoint="https://provider.example.com",
+    country="US",
+    currency="USD",
+    lat=40.7128,
+    lon=-74.0060,
+))
+```
+
+### Create an Order
+
+```python
+order = client.create_order(OrderCreate(
+    id="order-001",
+    transaction_id="txn-001",
+    bap_id="my-bap-001",
+    bpp_id="my-bpp-001",
+))
+```
+
+### Discover Nearby BPPs (GeoDNS)
+
+```python
+# Find BPPs in a specific country
+bpps = client.discover_nearest_bap(country="US")
+
+# Find BPPs near a geographic location
+nearby = client.discover_marketplace(lat=40.7128, lng=-74.0060, radius_km=50, limit=10)
+```
+
+### GBP (Google Business Profile)
+
+```python
+# Register a GBP account
+account = client.create_gbp_account(GbpAccountCreate(
+    email="merchant@example.com",
+    account_name="accounts/1234567890",
+))
+
+# Sync GBP locations as BPPs (auto-registers A2A agent cards)
+synced = client.sync_gbp_locations(account.id)
+print(f"{len(synced['bpps'])} BPPs synced")
+```
+
+### A2A Agent Discovery
+
+```python
+# Discover agents near a location (cross-protocol with GeoDNS)
+nearby = client.discover_marketplace(lat=40.7128, lng=-74.0060, radius_km=50, limit=10)
+
+# Register an agent card
+agent = client.register_agent_card(AgentCardRegister(
+    agent_id="agent-001",
+    name="Travel Booking Agent",
+    url="https://travel.example.com",
+    capabilities={"streaming": True},
+    skills=[{"id": "search", "name": "Travel Search"}],
+))
+
+# Discover agents by skill
+results = client.discover_agents(skill="booking")
+```
+
+### ANP (Agent Network Protocol)
+
+```python
+# Announce a DID to the network
+announcement = client.announce(AnpAnnouncementCreate(
+    announcement_id="ann-001",
+    did="did:example:123",
+    service_endpoint="https://agent.example.com",
+))
+
+# Register a witness node
+witness = client.register_witness(AnpWitnessRegister(
+    witness_id="witness-001",
+    did="did:example:witness-1",
+    endpoint="https://witness.example.com",
+    protocols=["gossip", "http"],
+))
+
+# Verify a DID document
+verification = client.verify(AnpVerificationVerify(
+    did="did:example:123",
+    did_document={"id": "did:example:123"},
+    method="key",
+))
+```
+
+### ACP (Agent Communication Protocol)
+
+```python
+# Register a credential issuer
+issuer = client.register_issuer(AcpIssuerRegister(
+    issuer_id="issuer-001",
+    name="Test Issuer",
+    authorization_endpoint="https://issuer.example.com/authorize",
+    token_endpoint="https://issuer.example.com/token",
+    jwks_uri="https://issuer.example.com/.well-known/jwks.json",
+))
+
+# Issue a token
+token = client.issue_token(AcpTokenIssue(
+    token_value="eyJhbGciOiJSUzI1NiIs...",
+    subject="did:example:subject-1",
+))
+
+# Submit a verifiable presentation
+presentation = client.submit_presentation(AcpPresentationSubmit(
+    presentation_id="vp-123",
+    holder_did="did:example:holder-1",
+    issuer_id="issuer-001",
+    claims={"age": 25},
+))
+```
+
+### Google Business Profile Sync
+
+```python
+# Register a GBP account
+account = client.create_gbp_account({
+    "email": "merchant@example.com",
+    "account_name": "accounts/1234567890",
+})
+
+# Sync GBP locations as BPPs (auto-registers A2A agent cards)
+result = client.sync_gbp_locations(account["id"])
+print(f"{len(result['bpps'])} BPPs synced")
+```
+
+### A2A Agent Discovery
+
+```python
+# Discover nearby BPPs via GeoDNS (maps to A2A agents)
+bpps = client.discover_nearest_bpp(country="US")
+
+# Register an agent card
+agent_card = client.register_agent_card({
+    "agent_id": "agent-001",
+    "name": "Travel Booking Agent",
+    "url": "https://travel.example.com",
+    "capabilities": {"streaming": True},
+    "skills": [{"id": "search", "name": "Travel Search"}],
+})
+
+# Send a message to a task
+message = client.send_message({
+    "message_id": "msg-001",
+    "context_id": "ctx-1",
+    "role": "user",
+    "parts": [{"type": "text", "text": "Find flights to NYC"}],
+})
+```
+
+### ANP (Agent Network Protocol)
+
+```python
+# Announce a DID to the network
+announcement = client.announce({
+    "announcement_id": "ann-001",
+    "did": "did:example:123",
+    "service_endpoint": "https://agent.example.com",
+})
+
+# Register a witness node
+witness = client.register_witness({
+    "witness_id": "witness-001",
+    "did": "did:example:witness-1",
+    "endpoint": "https://witness.example.com",
+    "protocols": ["gossip", "http"],
+})
+```
+
+### ACP (Agent Communication Protocol)
+
+```python
+# Register a credential issuer
+issuer = client.register_issuer({
+    "issuer_id": "issuer-001",
+    "name": "Test Issuer",
+    "authorization_endpoint": "https://issuer.example.com/authorize",
+    "token_endpoint": "https://issuer.example.com/token",
+    "jwks_uri": "https://issuer.example.com/.well-known/jwks.json",
+})
+
+# Issue a token
+token = client.issue_token({
+    "token_value": "eyJhbGciOiJSUzI1NiIs...",
+    "subject": "did:example:subject-1",
+})
+
+# Submit a verifiable presentation
+presentation = client.submit_presentation({
+    "id": "pres-001",
+    "presentation_id": "vp-123",
+    "vp": {"@context": ["..."], "type": "VerifiablePresentation"},
+    "credential_issuer_id": "issuer-001",
+    "holder": "did:example:holder-1",
+})
+```
+
+## API Reference
+
+### BeckNClientConfig
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `base_url` | `str` | `'http://localhost:4000/v1'` | API base URL |
+| `api_key` | `Optional[str]` | `None` | API key for authentication |
+| `timeout` | `int` | `30000` | Request timeout in milliseconds |
+
+### Methods
+
+#### Orders
+- `list_orders() -> list[Order]`
+- `create_order(data: OrderCreate) -> Order`
+- `get_order(id: str) -> Order`
+- `delete_order(id: str) -> None`
+
+#### BAPs
+- `list_baps() -> list[Bap]`
+- `list_baps_by_company(company_id: str) -> list[Bap]`
+- `list_baps_by_country(country: str) -> list[Bap]`
+- `list_baps_nearby(lat: float, lng: float, radius_km: int = 50) -> list[Bap]`
+- `create_bap(data: BapCreate) -> Bap`
+- `get_bap(bap_id: str) -> Bap`
+- `update_bap(bap_id: str, data: BapUpdate) -> Bap`
+
+#### BPPs
+- `list_bpps() -> list[Bpp]`
+- `list_bpps_by_company(company_id: str) -> list[Bpp]`
+- `list_bpps_by_country(country: str) -> list[Bpp]`
+- `list_bpps_nearby(lat: float, lng: float, radius_km: int = 50) -> list[Bpp]`
+- `create_bpp(data: BppCreate) -> Bpp`
+- `get_bpp(bpp_id: str) -> Bpp`
+- `update_bpp(bpp_id: str, data: BppUpdate) -> Bpp`
+
+#### Companies (B2B Multi-Tenant)
+- `list_companies() -> list[Company]`
+- `create_company(data: CompanyCreate) -> Company`
+- `get_company(company_id: str) -> Company`
+- `list_companies_by_domain(domain: str) -> list[Company]`
+
+#### API Keys
+- `list_api_keys() -> list[ApiKey]`
+- `create_api_key(data: ApiKeyCreate) -> ApiKeyResponse`
+- `verify_api_key(secret: str) -> ApiKeyVerifyResponse`
+- `revoke_api_key(key_id: str) -> ApiKey`
+- `rotate_api_key(key_id: str) -> ApiKeyResponse`
+
+#### GeoDNS Discovery
+- `discover_nearest_bap(country: str = None, city: str = None) -> GeoDnsResult`
+- `discover_nearest_bpp(country: str = None, city: str = None) -> GeoDnsResult`
+- `discover_marketplace(lat: float, lng: float, radius_km: int = 50, limit: int = 10) -> list[GeoDnsResult]`
+
+#### GBP (Google Business Profile)
+- `list_gbp_accounts() -> list[GbpAccount]`
+- `create_gbp_account(data: dict) -> GbpAccount`
+- `sync_gbp_locations(account_id: str) -> dict`
+
+#### A2A (Agent-to-Agent)
+- `list_agent_cards() -> list[AgentCard]`
+- `register_agent_card(data: AgentCardRegister) -> AgentCard`
+- `list_tasks() -> list[A2ATask]`
+- `create_task(data: A2ATaskCreate) -> A2ATask`
+- `send_message(data: A2ATaskMessageSend) -> A2ATaskMessage`
+- `list_messages() -> list[A2ATaskMessage]`
+- `list_artifacts() -> list[A2AArtifact]`
+- `create_artifact(data: A2AArtifactCreate) -> A2AArtifact`
+
+#### MCP (Model Context Protocol)
+- `list_tools() -> list[McpTool]`
+- `create_tool(data: McpToolCreate) -> McpTool`
+- `list_resources() -> list[McpResource]`
+- `create_resource(data: McpResourceCreate) -> McpResource`
+- `list_prompts() -> list[McpPrompt]`
+- `create_prompt(data: McpPromptCreate) -> McpPrompt`
+
+#### ACP (Agent Communication Protocol)
+- `list_issuers() -> list[AcpIssuer]`
+- `register_issuer(data: AcpIssuerRegister) -> AcpIssuer`
+- `list_tokens() -> list[AcpToken]`
+- `issue_token(data: AcpTokenIssue) -> AcpToken`
+- `introspect_token(token: str) -> AcpToken`
+- `list_presentations() -> list[AcpPresentation]`
+- `submit_presentation(data: AcpPresentationSubmit) -> AcpPresentation`
+- `list_policies() -> list[AcpAccessPolicy]`
+- `create_policy(data: AcpAccessPolicyCreate) -> AcpAccessPolicy`
+
+#### ANP (Agent Network Protocol)
+- `list_announcements() -> list[AnpAnnouncement]`
+- `announce(data: AnpAnnouncementCreate) -> AnpAnnouncement`
+- `list_witnesses() -> list[AnpWitness]`
+- `register_witness(data: AnpWitnessRegister) -> AnpWitness`
+- `verify(data: AnpVerificationVerify) -> AnpVerification`
+
+#### Subscriptions
+- `list_subscriptions() -> list[Subscription]`
+- `create_subscription(data: SubscriptionCreate) -> Subscription`
+- `cancel_subscription(sub_id: str) -> Subscription`
+- `renew_subscription(sub_id: str) -> Subscription`
+
+## License
+
+Apache-2.0

beckn_sdk-1.0.0/beckn/__init__.py

@@ -0,0 +1,40 @@
+"""BeckN Protocol SDK."""
+
+__version__ = "1.0.0"
+
+from .client import BeckNClient, BeckNError
+from .types import (
+    Bap, BapCreate, BapUpdate, Bpp, BppCreate, BppUpdate,
+    Order, OrderCreate, OrderUpdate, OrderState, Item, ItemCreate,
+    Provider, ProviderCreate, Fulfillment, FulfillmentCreate,
+    Subscription, SubscriptionCreate, SubscriptionStatus, SubscriberType,
+    ApiKey, ApiKeyCreate, ApiKeyResponse, ApiKeyVerifyRequest, ApiKeyVerifyResponse,
+    GeoLocation, GeoDnsResult, GeoDiscoveryConfig,
+    AgentCard, AgentCardRegister, A2ATask, A2ATaskCreate, TaskStatus,
+    A2ATaskMessage, A2ATaskMessageSend, A2AArtifact, A2AArtifactCreate,
+    McpTool, McpToolCreate, McpResource, McpResourceCreate,
+    McpPrompt, McpPromptCreate, McpClientType, McpClientRegister, TransportType,
+    AcpIssuer, AcpIssuerRegister, AcpToken, AcpTokenIssue,
+    AcpPresentation, AcpPresentationSubmit, AcpAccessPolicy, AcpAccessPolicyCreate,
+    AnpAnnouncement, AnpAnnouncementCreate, AnpWitness, AnpWitnessRegister,
+    AnpVerification, AnpVerificationVerify, MessageRole,
+    BeckNClientConfig,
+)
+
+__all__ = [
+    "BeckNClient", "BeckNError", "BeckNClientConfig",
+    "Bap", "BapCreate", "BapUpdate", "Bpp", "BppCreate", "BppUpdate",
+    "Order", "OrderCreate", "OrderUpdate", "OrderState", "Item", "ItemCreate",
+    "Provider", "ProviderCreate", "Fulfillment", "FulfillmentCreate",
+    "Subscription", "SubscriptionCreate", "SubscriptionStatus", "SubscriberType",
+    "ApiKey", "ApiKeyCreate", "ApiKeyResponse", "ApiKeyVerifyRequest", "ApiKeyVerifyResponse",
+    "GeoLocation", "GeoDnsResult", "GeoDiscoveryConfig",
+    "AgentCard", "AgentCardRegister", "A2ATask", "A2ATaskCreate", "TaskStatus",
+    "A2ATaskMessage", "A2ATaskMessageSend", "A2AArtifact", "A2AArtifactCreate",
+    "McpTool", "McpToolCreate", "McpResource", "McpResourceCreate",
+    "McpPrompt", "McpPromptCreate", "McpClientType", "McpClientRegister", "TransportType",
+    "AcpIssuer", "AcpIssuerRegister", "AcpToken", "AcpTokenIssue",
+    "AcpPresentation", "AcpPresentationSubmit", "AcpAccessPolicy", "AcpAccessPolicyCreate",
+    "AnpAnnouncement", "AnpAnnouncementCreate", "AnpWitness", "AnpWitnessRegister",
+    "AnpVerification", "AnpVerificationVerify", "MessageRole",
+]

beckn_sdk-1.0.0/beckn/client.py

@@ -0,0 +1,288 @@
+"""Client module for the BeckN Protocol SDK."""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import Any, Optional, TypeVar
+from dataclasses import asdict
+
+import httpx
+
+from .types import (
+    Bap, BapCreate, BapUpdate, Bpp, BppCreate, BppUpdate,
+    Order, OrderCreate, OrderUpdate, Item, ItemCreate,
+    Provider, ProviderCreate, Fulfillment, FulfillmentCreate,
+    Subscription, SubscriptionCreate,
+    ApiKey, ApiKeyCreate, ApiKeyResponse, ApiKeyVerifyRequest, ApiKeyVerifyResponse,
+    ErrorResponse, GeoDnsResult, GeoLocation,
+    AgentCard, AgentCardRegister, A2ATask, A2ATaskCreate,
+    A2ATaskMessage, A2ATaskMessageSend, A2AArtifact, A2AArtifactCreate,
+    McpTool, McpToolCreate, McpResource, McpResourceCreate,
+    McpPrompt, McpPromptCreate, McpClientType, McpClientRegister,
+    AcpIssuer, AcpIssuerRegister, AcpToken, AcpTokenIssue,
+    AcpPresentation, AcpPresentationSubmit, AcpAccessPolicy, AcpAccessPolicyCreate,
+    AnpAnnouncement, AnpAnnouncementCreate, AnpWitness, AnpWitnessRegister,
+    AnpVerification, AnpVerificationVerify,
+    Company, CompanyCreate, BeckNClientConfig,
+)
+
+T = TypeVar('T')
+
+
+class BeckNError(Exception):
+    def __init__(self, message: str, status: int = 500, response: Optional[ErrorResponse] = None):
+        super().__init__(message)
+        self.status = status
+        self.response = response
+
+
+def _to_dict(obj: Any) -> dict[str, Any]:
+    if isinstance(obj, dict):
+        return obj
+    if hasattr(obj, '__dict__'):
+        return {k: v for k, v in obj.__dict__.items() if v is not None}
+    return asdict(obj)
+
+
+def _from_dict(cls: type, data: dict[str, Any]) -> Any:
+    if hasattr(cls, '__dataclass_fields__'):
+        field_names = set(cls.__dataclass_fields__.keys())
+        filtered = {k: v for k, v in data.items() if k in field_names}
+        return cls(**filtered)
+    return data
+
+
+class BeckNClient:
+    def __init__(self, config: Optional[BeckNClientConfig] = None):
+        if config is None:
+            config = BeckNClientConfig()
+        self.base_url = config.base_url or os.environ.get('BECKN_API_URL', 'http://localhost:4000/v1')
+        self.api_key = config.api_key or os.environ.get('BECKN_API_KEY')
+        self.timeout = config.timeout or 30
+        self._client = httpx.Client(timeout=self.timeout, base_url=self.base_url)
+        self._async_client = httpx.AsyncClient(timeout=self.timeout, base_url=self.base_url)
+
+    def _headers(self) -> dict[str, str]:
+        h = {'Content-Type': 'application/json', 'Accept': 'application/json'}
+        if self.api_key:
+            h['x-api-key'] = self.api_key
+        return h
+
+    def _request(self, method: str, path: str, body: Optional[dict] = None) -> dict[str, Any]:
+        kwargs = {'headers': self._headers()}
+        if body is not None:
+            kwargs['content'] = json.dumps(body)
+        resp = self._client.request(method, path, **kwargs)
+        if not resp.is_success:
+            try:
+                err = resp.json()
+            except Exception:
+                err = {'message': resp.text}
+            raise BeckNError(err.get('message', f'HTTP {resp.status_code}'), resp.status_code, _from_dict(ErrorResponse, err))
+        if resp.status_code == 204:
+            return None
+        return resp.json()
+
+    # === BeckN Orders ===
+    def list_orders(self) -> list[Order]:
+        return [Order(**o) for o in self._request('GET', '/orders')]
+
+    def create_order(self, data: OrderCreate) -> Order:
+        return Order(**self._request('POST', '/orders', _to_dict(data)))
+
+    def get_order(self, order_id: str) -> Order:
+        return Order(**self._request('GET', f'/orders/{order_id}'))
+
+    def update_order(self, order_id: str, data: OrderUpdate) -> Order:
+        return Order(**self._request('PATCH', f'/orders/{order_id}', _to_dict(data)))
+
+    def delete_order(self, order_id: str) -> None:
+        self._request('DELETE', f'/orders/{order_id}')
+
+    # === BAPs ===
+    def list_baps(self) -> list[Bap]:
+        return [Bap(**b) for b in self._request('GET', '/baps')]
+
+    def list_baps_by_company(self, company_id: str) -> list[Bap]:
+        return [Bap(**b) for b in self._request('GET', f'/baps?company_id={company_id}')]
+
+    def create_bap(self, data: BapCreate) -> Bap:
+        return Bap(**self._request('POST', '/baps', _to_dict(data)))
+
+    def get_bap(self, bap_id: str) -> Bap:
+        return Bap(**self._request('GET', f'/baps/{bap_id}'))
+
+    def update_bap(self, bap_id: str, data: BapUpdate) -> Bap:
+        return Bap(**self._request('PATCH', f'/baps/{bap_id}', _to_dict(data)))
+
+    # === BPPs ===
+    def list_bpps(self) -> list[Bpp]:
+        return [Bpp(**b) for b in self._request('GET', '/bpps')]
+
+    def list_bpps_by_company(self, company_id: str) -> list[Bpp]:
+        return [Bpp(**b) for b in self._request('GET', f'/bpps?company_id={company_id}')]
+
+    def create_bpp(self, data: BppCreate) -> Bpp:
+        return Bpp(**self._request('POST', '/bpps', _to_dict(data)))
+
+    def get_bpp(self, bpp_id: str) -> Bpp:
+        return Bpp(**self._request('GET', f'/bpps/{bpp_id}'))
+
+    def update_bpp(self, bpp_id: str, data: BppUpdate) -> Bpp:
+        return Bpp(**self._request('PATCH', f'/bpps/{bpp_id}', _to_dict(data)))
+
+    # === Items ===
+    def list_items(self) -> list[Item]:
+        return [Item(**i) for i in self._request('GET', '/items')]
+
+    def create_item(self, data: ItemCreate) -> Item:
+        return Item(**self._request('POST', '/items', _to_dict(data)))
+
+    def get_item(self, item_id: str) -> Item:
+        return Item(**self._request('GET', f'/items/{item_id}'))
+
+    # === Providers ===
+    def list_providers(self) -> list[Provider]:
+        return [Provider(**p) for p in self._request('GET', '/providers')]
+
+    def create_provider(self, data: ProviderCreate) -> Provider:
+        return Provider(**self._request('POST', '/providers', _to_dict(data)))
+
+    def get_provider(self, provider_id: str) -> Provider:
+        return Provider(**self._request('GET', f'/providers/{provider_id}'))
+
+    def delete_provider(self, provider_id: str) -> None:
+        self._request('DELETE', f'/providers/{provider_id}')
+
+    # === Fulfillments ===
+    def list_fulfillments(self) -> list[Fulfillment]:
+        return [Fulfillment(**f) for f in self._request('GET', '/fulfillments')]
+
+    def create_fulfillment(self, data: FulfillmentCreate) -> Fulfillment:
+        return Fulfillment(**self._request('POST', '/fulfillments', _to_dict(data)))
+
+    def track_fulfillment(self, tracking_id: str) -> list[Fulfillment]:
+        return [Fulfillment(**f) for f in self._request('POST', '/fulfillments/track', {'tracking_id': tracking_id})]
+
+    # === Subscriptions ===
+    def list_subscriptions(self) -> list[Subscription]:
+        return [Subscription(**s) for s in self._request('GET', '/subscriptions')]
+
+    def create_subscription(self, data: SubscriptionCreate) -> Subscription:
+        return Subscription(**self._request('POST', '/subscriptions', _to_dict(data)))
+
+    def get_subscription(self, sub_id: str) -> Subscription:
+        return Subscription(**self._request('GET', f'/subscriptions/{sub_id}'))
+
+    def cancel_subscription(self, sub_id: str) -> Subscription:
+        return Subscription(**self._request('POST', f'/subscriptions/{sub_id}/cancel', {}))
+
+    def renew_subscription(self, sub_id: str) -> Subscription:
+        return Subscription(**self._request('POST', f'/subscriptions/{sub_id}/renew', {}))
+
+    # === API Keys ===
+    def list_api_keys(self) -> list[ApiKey]:
+        return [ApiKey(**k) for k in self._request('GET', '/api-keys')]
+
+    def create_api_key(self, data: ApiKeyCreate) -> ApiKeyResponse:
+        return ApiKeyResponse(**self._request('POST', '/api-keys', _to_dict(data)))
+
+    def get_api_key(self, key_id: str) -> ApiKey:
+        return ApiKey(**self._request('GET', f'/api-keys/{key_id}'))
+
+    def verify_api_key(self, secret: str) -> ApiKeyVerifyResponse:
+        resp = self._request('POST', '/api-keys/verify', {'secret': secret})
+        return ApiKeyVerifyResponse(**resp)
+
+    def revoke_api_key(self, key_id: str) -> ApiKey:
+        return ApiKey(**self._request('POST', f'/api-keys/{key_id}/revoke', {}))
+
+    def rotate_api_key(self, key_id: str) -> ApiKeyResponse:
+        return ApiKeyResponse(**self._request('POST', f'/api-keys/{key_id}/rotate', {}))
+
+    def list_api_keys_by_owner(self, owner_id: str) -> list[ApiKey]:
+        return [ApiKey(**k) for k in self._request('GET', f'/api-keys/owner/{owner_id}')]
+
+    # === GeoDNS Discovery ===
+    def discover_nearest_bap(self, country: Optional[str] = None, city: Optional[str] = None) -> GeoDnsResult:
+        from urllib.parse import urlencode
+        params = []
+        if country: params.append(f'country={country}')
+        if city: params.append(f'city={city}')
+        query = urlencode({'country': country or '', 'city': city or ''})
+        resp = self._request('GET', f'/geodns/baps?{query}')
+        loc = GeoLocation(**resp['location'])
+        return GeoDnsResult(**resp, location=loc)
+
+    def discover_nearest_bpp(self, country: Optional[str] = None, city: Optional[str] = None) -> GeoDnsResult:
+        from urllib.parse import urlencode
+        query = urlencode({'country': country or '', 'city': city or ''})
+        resp = self._request('GET', f'/geodns/bpps?{query}')
+        loc = GeoLocation(**resp['location'])
+        return GeoDnsResult(**resp, location=loc)
+
+    def discover_marketplace(self, lat: float, lng: float, radius_km: int = 50, limit: int = 10) -> list[GeoDnsResult]:
+        resp = self._request('GET', f'/geodns/marketplaces?lat={lat}&lng={lng}&radius_km={radius_km}&limit={limit}')
+        return [GeoDnsResult(**r, location=GeoLocation(**r['location'])) for r in resp]
+
+    # === A2A ===
+    def list_agent_cards(self) -> list[AgentCard]:
+        return [AgentCard(**a) for a in self._request('GET', '/a2a/agent-cards')]
+
+    def register_agent_card(self, data: AgentCardRegister) -> AgentCard:
+        return AgentCard(**self._request('POST', '/a2a/agent-cards', _to_dict(data)))
+
+    def get_agent_card(self, agent_id: str) -> AgentCard:
+        return AgentCard(**self._request('GET', f'/a2a/agent-cards/{agent_id}'))
+
+    # === MCP ===
+    def list_tools(self) -> list[McpTool]:
+        return [McpTool(**t) for t in self._request('GET', '/mcp/tools')]
+
+    def create_tool(self, data: McpToolCreate) -> McpTool:
+        return McpTool(**self._request('POST', '/mcp/tools', _to_dict(data)))
+
+    # === ACP ===
+    def list_issuers(self) -> list[AcpIssuer]:
+        return [AcpIssuer(**i) for i in self._request('GET', '/acp/issuers')]
+
+    def register_issuer(self, data: AcpIssuerRegister) -> AcpIssuer:
+        return AcpIssuer(**self._request('POST', '/acp/issuers', _to_dict(data)))
+
+    def issue_token(self, data: AcpTokenIssue) -> AcpToken:
+        return AcpToken(**self._request('POST', '/acp/tokens', _to_dict(data)))
+
+    # === ANP ===
+    def list_announcements(self) -> list[AnpAnnouncement]:
+        return [AnpAnnouncement(**a) for a in self._request('GET', '/anp/announcements')]
+
+    def announce(self, data: AnpAnnouncementCreate) -> AnpAnnouncement:
+        return AnpAnnouncement(**self._request('POST', '/anp/announcements', _to_dict(data)))
+
+    # === Companies (B2B Multi-Tenant) ===
+    def list_companies(self) -> list[Company]:
+        return [Company(**c) for c in self._request('GET', '/companies')]
+
+    def create_company(self, data: CompanyCreate) -> Company:
+        return Company(**self._request('POST', '/companies', _to_dict(data)))
+
+    def get_company(self, company_id: str) -> Company:
+        return Company(**self._request('GET', f'/companies/{company_id}'))
+
+    def list_companies_by_domain(self, domain: str) -> list[Company]:
+        return [Company(**c) for c in self._request('GET', f'/companies?domain={domain}')]
+
+    # === GBP (Google Business Profile) ===
+    def list_gbp_accounts(self) -> list[Any]:
+        return self._request('GET', '/gbp/accounts')
+
+    def create_gbp_account(self, data: dict[str, Any]) -> Any:
+        return self._request('POST', '/gbp/accounts', data)
+
+    def sync_gbp_locations(self, account_id: str) -> dict[str, Any]:
+        return self._request('POST', f'/gbp/accounts/{account_id}/sync', {})
+
+    # === Health ===
+    def health(self) -> dict[str, Any]:
+        return self._request('GET', '/health')