limitguard 0.1.0__py3-none-any.whl

limitguard/__init__.py

@@ -0,0 +1,37 @@
+"""LimitGuard.ai Python SDK - Trust Intelligence API client."""
+
+from limitguard.client import LimitGuardClient
+from limitguard.exceptions import (
+    AuthenticationError,
+    LimitGuardError,
+    PaymentRequiredError,
+    RateLimitError,
+    ServerError,
+    ValidationError,
+)
+from limitguard.models import (
+    Cluster,
+    Recommendation,
+    RiskResponse,
+    TopFactor,
+    TrustLevel,
+    TrustResponse,
+)
+
+__all__ = [
+    "LimitGuardClient",
+    "LimitGuardError",
+    "AuthenticationError",
+    "PaymentRequiredError",
+    "RateLimitError",
+    "ServerError",
+    "ValidationError",
+    "TrustResponse",
+    "RiskResponse",
+    "TrustLevel",
+    "Recommendation",
+    "Cluster",
+    "TopFactor",
+]
+
+__version__ = "0.1.0"

limitguard/client.py

@@ -0,0 +1,219 @@
+"""
+Async HTTP client for LimitGuard.ai Trust Intelligence API.
+
+Usage with API key:
+    async with LimitGuardClient(api_key="lg_live_...") as client:
+        result = await client.check_entity("Acme B.V.", "NL", kvk_number="12345678")
+
+Usage with Solana wallet (x402 pay-per-call):
+    from limitguard.x402 import SolanaWallet
+    from solders.keypair import Keypair
+    wallet = SolanaWallet(keypair=Keypair.from_base58_string(PRIVATE_KEY))
+    async with LimitGuardClient(wallet=wallet) as client:
+        result = await client.check_entity("Acme B.V.", "NL")
+"""
+
+import asyncio
+
+import httpx
+
+from limitguard.exceptions import (
+    AuthenticationError,
+    LimitGuardError,
+    PaymentRequiredError,
+    RateLimitError,
+    ServerError,
+    ValidationError,
+)
+from limitguard.models import RiskResponse, TrustResponse
+
+_RETRYABLE_STATUS = {429, 500, 502, 503, 504}
+_MAX_RETRIES = 3
+_BACKOFF_BASE = 1.0  # seconds
+
+
+class LimitGuardClient:
+    """Async client for the LimitGuard.ai API.
+
+    Supports two auth modes:
+    - API key: subscription-based access (X-API-Key header)
+    - Wallet: x402 pay-per-call with crypto (PAYMENT-SIGNATURE header)
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        wallet=None,
+        base_url: str = "https://api.limitguard.ai",
+        timeout: float = 30.0,
+    ):
+        if not api_key and not wallet:
+            raise ValueError("Provide api_key, wallet, or both")
+        self._api_key = api_key or ""
+        self._wallet = wallet
+        self._base_url = base_url.rstrip("/")
+        headers = {"Content-Type": "application/json"}
+        if api_key:
+            headers["X-API-Key"] = api_key
+        self._client = httpx.AsyncClient(
+            base_url=self._base_url,
+            headers=headers,
+            timeout=timeout,
+        )
+
+    async def _request(
+        self,
+        method: str,
+        path: str,
+        json: dict | None = None,
+        params: dict | None = None,
+    ) -> dict:
+        """Make an HTTP request with retry on 429/5xx and auto-pay on 402."""
+        last_exc: Exception | None = None
+
+        for attempt in range(_MAX_RETRIES):
+            try:
+                response = await self._client.request(
+                    method, path, json=json, params=params,
+                )
+            except httpx.HTTPError as exc:
+                last_exc = LimitGuardError(f"HTTP error: {exc}")
+                await asyncio.sleep(_BACKOFF_BASE * (2 ** attempt))
+                continue
+
+            if response.status_code == 200:
+                return response.json()
+
+            # Auto-pay on 402 if wallet is configured
+            if response.status_code == 402 and self._wallet:
+                return await self._pay_and_retry(response, method, path, json, params)
+
+            if response.status_code in _RETRYABLE_STATUS and attempt < _MAX_RETRIES - 1:
+                retry_after = response.headers.get("retry-after")
+                wait = float(retry_after) if retry_after else _BACKOFF_BASE * (2 ** attempt)
+                await asyncio.sleep(wait)
+                continue
+
+            self._raise_for_status(response)
+
+        if last_exc:
+            raise last_exc
+        raise LimitGuardError("Max retries exceeded")
+
+    async def _pay_and_retry(
+        self,
+        response_402: httpx.Response,
+        method: str,
+        path: str,
+        json: dict | None,
+        params: dict | None,
+    ) -> dict:
+        """Handle 402 by making x402 payment and retrying."""
+        from limitguard.x402 import parse_402_response
+
+        body = response_402.json()
+        payment_info = parse_402_response(body)
+
+        # Prefer Solana for SolanaWallet
+        from limitguard.x402 import SolanaWallet
+        if isinstance(self._wallet, SolanaWallet) and "solana" in payment_info:
+            info = payment_info["solana"]
+        elif "base" in payment_info:
+            info = payment_info["base"]
+        elif "solana" in payment_info:
+            info = payment_info["solana"]
+        else:
+            raise PaymentRequiredError("No supported payment chain in 402 response")
+
+        payment_header = await self._wallet.build_payment(
+            amount_micro_usdc=info["amount"],
+            recipient=info["recipient"],
+        )
+
+        # Retry with payment header
+        paid_response = await self._client.request(
+            method, path, json=json, params=params,
+            headers={"PAYMENT-SIGNATURE": payment_header},
+        )
+
+        if paid_response.status_code == 200:
+            return paid_response.json()
+
+        self._raise_for_status(paid_response)
+        raise LimitGuardError("Payment accepted but request failed")
+
+    @staticmethod
+    def _raise_for_status(response: httpx.Response) -> None:
+        """Map HTTP status codes to typed exceptions."""
+        body = response.json() if response.headers.get("content-type", "").startswith("application/json") else {}
+        detail = body.get("detail", body.get("error", response.text))
+
+        if response.status_code == 401:
+            raise AuthenticationError(str(detail))
+        if response.status_code == 402:
+            raise PaymentRequiredError(str(detail))
+        if response.status_code == 422:
+            raise ValidationError(str(detail), detail=str(body))
+        if response.status_code == 429:
+            retry_after = response.headers.get("retry-after")
+            raise RateLimitError(
+                str(detail),
+                retry_after=float(retry_after) if retry_after else None,
+            )
+        if response.status_code >= 500:
+            raise ServerError(str(detail), status_code=response.status_code)
+
+        raise LimitGuardError(f"Unexpected status {response.status_code}: {detail}", status_code=response.status_code)
+
+    async def check_entity(
+        self,
+        entity_name: str,
+        country: str,
+        *,
+        kvk_number: str | None = None,
+        cbe_number: str | None = None,
+        domain: str | None = None,
+        iban: str | None = None,
+        vat_number: str | None = None,
+    ) -> TrustResponse:
+        """POST /v1/entity/check - Full trust intelligence."""
+        payload: dict = {"entity_name": entity_name, "country": country}
+        if kvk_number:
+            payload["kvk_number"] = kvk_number
+        if cbe_number:
+            payload["cbe_number"] = cbe_number
+        if domain:
+            payload["domain"] = domain
+        if iban:
+            payload["iban"] = iban
+        if vat_number:
+            payload["vat_number"] = vat_number
+
+        data = await self._request("POST", "/v1/entity/check", json=payload)
+        return TrustResponse(**data)
+
+    async def risk_score(self, entity_name: str, country: str) -> RiskResponse:
+        """POST /v1/risk/score - Quick risk assessment."""
+        data = await self._request("POST", "/v1/risk/score", json={
+            "entity_name": entity_name,
+            "country": country,
+        })
+        return RiskResponse(**data)
+
+    async def get_usage(self, period: str = "day") -> dict:
+        """GET /v1/usage/summary - Usage stats for current API key."""
+        return await self._request("GET", "/v1/usage/summary", params={"period": period})
+
+    async def verify_audit(self) -> dict:
+        """GET /v1/audit/verify - Verify audit trail integrity."""
+        return await self._request("GET", "/v1/audit/verify")
+
+    async def close(self) -> None:
+        """Close the underlying httpx client."""
+        await self._client.aclose()
+
+    async def __aenter__(self) -> "LimitGuardClient":
+        return self
+
+    async def __aexit__(self, *args: object) -> None:
+        await self.close()

limitguard/exceptions.py

@@ -0,0 +1,50 @@
+"""
+Typed exceptions for LimitGuard SDK.
+
+Maps HTTP status codes to specific exception types.
+"""
+
+
+class LimitGuardError(Exception):
+    """Base exception for all LimitGuard SDK errors."""
+
+    def __init__(self, message: str, status_code: int | None = None):
+        self.status_code = status_code
+        super().__init__(message)
+
+
+class AuthenticationError(LimitGuardError):
+    """Raised on 401 - invalid or missing API key."""
+
+    def __init__(self, message: str = "Invalid or missing API key"):
+        super().__init__(message, status_code=401)
+
+
+class PaymentRequiredError(LimitGuardError):
+    """Raised on 402 - payment required (x402 protocol)."""
+
+    def __init__(self, message: str = "Payment required"):
+        super().__init__(message, status_code=402)
+
+
+class RateLimitError(LimitGuardError):
+    """Raised on 429 - rate limit or monthly quota exceeded."""
+
+    def __init__(self, message: str = "Rate limit exceeded", retry_after: float | None = None):
+        self.retry_after = retry_after
+        super().__init__(message, status_code=429)
+
+
+class ValidationError(LimitGuardError):
+    """Raised on 422 - request validation failed."""
+
+    def __init__(self, message: str = "Validation error", detail: str | None = None):
+        self.detail = detail
+        super().__init__(message, status_code=422)
+
+
+class ServerError(LimitGuardError):
+    """Raised on 5xx - server-side error."""
+
+    def __init__(self, message: str = "Server error", status_code: int = 500):
+        super().__init__(message, status_code=status_code)

limitguard/models.py

@@ -0,0 +1,61 @@
+"""
+Response models for LimitGuard SDK.
+
+Mirrors the API response schemas so callers get typed objects.
+"""
+
+from enum import Enum
+from pydantic import BaseModel, Field
+
+
+class TrustLevel(str, Enum):
+    HIGH = "high"
+    MEDIUM = "medium"
+    LOW = "low"
+    CRITICAL = "critical"
+
+
+class Recommendation(str, Enum):
+    PROCEED = "proceed"
+    REVIEW = "review"
+    EDD = "enhanced_due_diligence"
+    BLOCK = "block"
+
+
+class Cluster(str, Enum):
+    ESTABLISHED_EU_ENTERPRISE = "established_eu_enterprise"
+    ESTABLISHED_EU_SME = "established_eu_sme"
+    VERIFIED_STARTUP = "verified_startup"
+    UNVERIFIED_NEW = "unverified_new"
+    HIGH_RISK_JURISDICTION = "high_risk_jurisdiction"
+    SANCTIONS_FLAGGED = "sanctions_flagged"
+    INSUFFICIENT_DATA = "insufficient_data"
+    MIXED_SIGNALS = "mixed_signals"
+
+
+class TopFactor(BaseModel):
+    source: str
+    signal: str
+    impact: str
+    weight: float
+
+
+class TrustResponse(BaseModel):
+    trust_score: int = Field(ge=0, le=100)
+    trust_level: TrustLevel
+    cluster: Cluster
+    recommendation: Recommendation
+    confidence: float = Field(ge=0, le=1)
+    top_factors: list[TopFactor]
+    correlations: dict[str, float] = Field(default_factory=dict)
+    sources_checked: int = Field(ge=0)
+    processing_time_ms: int = Field(ge=0)
+    version: str = "1.0"
+
+
+class RiskResponse(BaseModel):
+    risk_score: int = Field(ge=0, le=100)
+    risk_level: TrustLevel
+    recommendation: Recommendation
+    top_factors: list[TopFactor]
+    processing_time_ms: int = Field(ge=0)

limitguard/x402.py

@@ -0,0 +1,231 @@
+"""
+x402 payment support for LimitGuard SDK.
+
+Enables AI agents and programmatic clients to pay for API calls
+using Solana USDC or Base USDC via the x402 HTTP payment protocol.
+
+Solana flow:
+  1. Build SPL TransferChecked instruction (USDC)
+  2. Sign and broadcast transaction
+  3. Wait for confirmation
+  4. Send tx signature in PAYMENT-SIGNATURE header
+
+Base (EVM) flow:
+  1. Sign EIP-712 typed data (EIP-3009 TransferWithAuthorization)
+  2. Send signature in PAYMENT-SIGNATURE header
+"""
+
+import asyncio
+import base64
+import json
+import time
+
+import httpx
+
+# Solana constants
+USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
+TOKEN_PROGRAM = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+ATA_PROGRAM = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+COMPUTE_BUDGET = "ComputeBudget111111111111111111111111111111"
+SOLANA_CHAIN_ID = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp"
+
+
+class SolanaWallet:
+    """Solana wallet for programmatic x402 payments.
+
+    Usage:
+        from solders.keypair import Keypair
+        wallet = SolanaWallet(keypair=Keypair.from_base58_string(PRIVATE_KEY))
+    """
+
+    def __init__(
+        self,
+        keypair,
+        rpc_url: str = "https://api.mainnet-beta.solana.com",
+    ):
+        self._keypair = keypair
+        self._rpc_url = rpc_url
+
+    @property
+    def pubkey(self) -> str:
+        return str(self._keypair.pubkey())
+
+    async def build_payment(
+        self,
+        amount_micro_usdc: int,
+        recipient: str,
+    ) -> str:
+        """Build, sign, broadcast a USDC transfer and return PAYMENT-SIGNATURE header.
+
+        Args:
+            amount_micro_usdc: Amount in micro-USDC (e.g. 100000 = $0.10)
+            recipient: Recipient Solana address
+
+        Returns:
+            Base64-encoded payment header value for PAYMENT-SIGNATURE header.
+        """
+        try:
+            from solders.compute_budget import set_compute_unit_limit, set_compute_unit_price
+            from solders.hash import Hash
+            from solders.keypair import Keypair
+            from solders.message import MessageV0
+            from solders.pubkey import Pubkey
+            from solders.transaction import VersionedTransaction
+            import spl.token.instructions as spl_token
+        except ImportError:
+            raise ImportError(
+                "Solana payment requires: pip install 'limitguard[solana]' "
+                "(installs solders, solana, spl-token)"
+            )
+
+        sender_key = self._keypair.pubkey()
+        recipient_key = Pubkey.from_string(recipient)
+        usdc_mint = Pubkey.from_string(USDC_MINT)
+        token_prog = Pubkey.from_string(TOKEN_PROGRAM)
+        ata_prog = Pubkey.from_string(ATA_PROGRAM)
+
+        # Derive ATAs
+        sender_ata = Pubkey.find_program_address(
+            [bytes(sender_key), bytes(token_prog), bytes(usdc_mint)],
+            ata_prog,
+        )[0]
+        recipient_ata = Pubkey.find_program_address(
+            [bytes(recipient_key), bytes(token_prog), bytes(usdc_mint)],
+            ata_prog,
+        )[0]
+
+        # Get recent blockhash
+        async with httpx.AsyncClient(timeout=15) as client:
+            resp = await client.post(self._rpc_url, json={
+                "jsonrpc": "2.0", "id": 1,
+                "method": "getLatestBlockhash",
+                "params": [{"commitment": "confirmed"}],
+            })
+            result = resp.json()
+            if "error" in result:
+                raise RuntimeError(f"Blockhash fetch failed: {result['error']}")
+            bh_data = result["result"]["value"]
+            blockhash = Hash.from_string(bh_data["blockhash"])
+
+        # Build instructions
+        ix0 = set_compute_unit_limit(200_000)
+        ix1 = set_compute_unit_price(50_000)
+
+        # SPL TransferChecked
+        ix2 = spl_token.transfer_checked(
+            spl_token.TransferCheckedParams(
+                program_id=token_prog,
+                source=sender_ata,
+                mint=usdc_mint,
+                dest=recipient_ata,
+                owner=sender_key,
+                amount=amount_micro_usdc,
+                decimals=6,
+            )
+        )
+
+        # Build and sign transaction
+        msg = MessageV0.try_compile(
+            payer=sender_key,
+            instructions=[ix0, ix1, ix2],
+            address_lookup_table_accounts=[],
+            recent_blockhash=blockhash,
+        )
+        tx = VersionedTransaction(msg, [self._keypair])
+
+        # Broadcast
+        tx_bytes = bytes(tx)
+        async with httpx.AsyncClient(timeout=30) as client:
+            resp = await client.post(self._rpc_url, json={
+                "jsonrpc": "2.0", "id": 1,
+                "method": "sendTransaction",
+                "params": [
+                    base64.b64encode(tx_bytes).decode(),
+                    {"encoding": "base64", "skipPreflight": True},
+                ],
+            })
+            result = resp.json()
+            if "error" in result:
+                raise RuntimeError(f"Transaction failed: {result['error']}")
+            tx_sig = result["result"]
+
+        # Poll for confirmation
+        confirmed = False
+        async with httpx.AsyncClient(timeout=60) as client:
+            for _ in range(30):
+                await asyncio.sleep(2)
+                resp = await client.post(self._rpc_url, json={
+                    "jsonrpc": "2.0", "id": 1,
+                    "method": "getSignatureStatuses",
+                    "params": [[tx_sig]],
+                })
+                body = resp.json()
+                if "error" in body:
+                    # #343: an RPC error (auth, rate limit, malformed reply) is not
+                    # "not landed yet". Say so, with the signature, instead of
+                    # burning the whole budget and blaming the wallet's balance.
+                    raise RuntimeError(
+                        f"Confirmation poll failed for {tx_sig}: {body['error']}. "
+                        "The transaction was broadcast and may still land; check the "
+                        "signature before paying again."
+                    )
+                statuses = body.get("result", {}).get("value", [None])
+                st = statuses[0] if statuses else None
+                # #344: a transaction can be confirmed or finalized AND have failed
+                # (non-null err: missing ATA, insufficient balance, program error).
+                # err has to win, or a reverted transfer is reported as a payment.
+                if st and st.get("err"):
+                    raise RuntimeError(f"Transaction {tx_sig} failed on chain: {st['err']}")
+                if st and st.get("confirmationStatus") in ("confirmed", "finalized"):
+                    confirmed = True
+                    break
+
+        if not confirmed:
+            raise RuntimeError(
+                f"Transaction {tx_sig} not confirmed after 60s. "
+                "Wallet may have insufficient SOL for gas or USDC for payment."
+            )
+
+        # Build payment header
+        now = int(time.time())
+        payload = {
+            "chainId": SOLANA_CHAIN_ID,
+            "sender": str(sender_key),
+            "recipient": recipient,
+            "amount": str(amount_micro_usdc),
+            "nonce": tx_sig,
+            "validAfter": now - 10,
+            "validBefore": now + 300,
+            "signature": tx_sig,
+            "payload": {"txSignature": tx_sig},
+        }
+        return base64.b64encode(json.dumps(payload).encode()).decode()
+
+
+def parse_402_response(response_json: dict) -> dict:
+    """Parse a 402 response to extract payment requirements.
+
+    Returns dict with keys: amount, recipient, chain_id, fee_payer (Solana only).
+    """
+    accepts = response_json.get("accepts", [])
+    result = {}
+    for accept in accepts:
+        network = accept.get("network", "")
+        entry = {
+            "amount": int(accept.get("amount", 0)),
+            "recipient": accept.get("payTo", ""),
+            "chain_id": network,
+            "asset": accept.get("asset", ""),
+        }
+        # `or {}` not a default: an accepts entry may carry an explicit
+        # `"extra": null`, and `.get("extra", {})` returns None for that,
+        # so the caller would see AttributeError instead of a payment error.
+        fee_payer = (accept.get("extra") or {}).get("feePayer")
+        if fee_payer:
+            entry["fee_payer"] = fee_payer
+
+        if "solana" in network:
+            result["solana"] = entry
+        elif "eip155" in network:
+            result["base"] = entry
+    return result

limitguard-0.1.0.dist-info/METADATA

@@ -0,0 +1,112 @@
+Metadata-Version: 2.5
+Name: limitguard
+Version: 0.1.0
+Summary: Official Python SDK for the LimitGuard Trust Intelligence API
+Project-URL: Homepage, https://limitguard.ai
+Project-URL: Documentation, https://docs.limitguard.ai
+Project-URL: Issues, https://github.com/jwconsultancyteam/limitguard-mcp/issues
+Author: LimitGuard
+License-Expression: MIT
+License-File: LICENSE
+Keywords: compliance,kyb,limitguard,risk,trust,usdc,x402
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: AsyncIO
+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: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-asyncio; extra == 'dev'
+Requires-Dist: respx; extra == 'dev'
+Provides-Extra: solana
+Requires-Dist: solana>=0.34; extra == 'solana'
+Requires-Dist: solders>=0.21; extra == 'solana'
+Description-Content-Type: text/markdown
+
+# limitguard
+
+Official Python SDK for the [LimitGuard](https://limitguard.ai) Trust Intelligence API: entity verification and risk scoring for EU businesses, paid per call in USDC over x402 or covered by a subscription.
+
+## Install
+
+```bash
+pip install limitguard
+```
+
+With Solana wallet support, for agents that pay per call:
+
+```bash
+pip install 'limitguard[solana]'
+```
+
+Python 3.10 or newer.
+
+## Quickstart
+
+```python
+import asyncio
+from limitguard import LimitGuardClient
+
+
+async def main():
+    async with LimitGuardClient(api_key="lg_live_...") as client:
+        result = await client.check_entity("Acme BV", country="NL")
+        print(result.trust_score, result.trust_level, result.recommendation)
+
+
+asyncio.run(main())
+```
+
+`check_entity` returns a `TrustResponse` (`trust_score` 0-100, `trust_level`, `cluster`, `recommendation`, `confidence`, `top_factors`). `risk_score` is the cheaper two-source variant and returns a `RiskResponse`.
+
+## Paying for calls
+
+Two ways to satisfy the API's per-call price, and the client accepts either or both:
+
+| You pass | What happens |
+|---|---|
+| `api_key=` on a **paid** tier (`indie` and up) | The subscription covers usage. No per-call payment. |
+| `wallet=` | The client pays each call in USDC over x402 automatically when the API answers 402. |
+| both | Calls are paid by the wallet and attributed to the key. |
+
+A `free`-tier key identifies you and tracks usage; it does not pay for calls. On its own it will raise `PaymentRequiredError` on any paid endpoint. Add a wallet, or upgrade the key.
+
+Wallet example (Solana, needs the `[solana]` extra and a wallet holding SOL for gas and USDC for payments):
+
+```python
+from solders.keypair import Keypair
+from limitguard import LimitGuardClient
+from limitguard.x402 import SolanaWallet
+
+wallet = SolanaWallet(keypair=Keypair.from_base58_string(private_key))
+async with LimitGuardClient(wallet=wallet) as client:
+    result = await client.check_entity("Acme BV", country="NL")
+```
+
+A complete agent is in `examples/agent_with_wallet.py`, included in the source distribution (`pip download --no-binary :all: limitguard`).
+
+## Errors
+
+All exceptions subclass `LimitGuardError`: `AuthenticationError`, `PaymentRequiredError`, `RateLimitError`, `ValidationError`, `ServerError`. The client retries 429 and 5xx responses with backoff before raising.
+
+## Links
+
+- Documentation: https://docs.limitguard.ai
+- Quickstart and a free sandbox key (mock data, no wallet): https://api.limitguard.ai/v1/quickstart
+- x402 protocol: https://docs.limitguard.ai/x402-protocol
+- Issues and support: https://github.com/jwconsultancyteam/limitguard-mcp/issues
+
+## Version
+
+```python
+import limitguard
+print(limitguard.__version__)
+```
+
+Releases are tagged `sdk-v<version>` and published to PyPI from that tag.

limitguard-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+limitguard/__init__.py,sha256=Ya6sWSRAcCodtSZNXFmDZZj-XLZ6h_56UFgwT-vRWNM,732
+limitguard/client.py,sha256=R80aXQ8Fki5-_DFN26t7XiRsOxBuqQjBSpQvqm8boPk,7671
+limitguard/exceptions.py,sha256=eHokz2TsGgOp6Yg3RNAB-6nDTQ1Skgih_0GJHyXbWCI,1549
+limitguard/models.py,sha256=92wKryKmNKD6OJuqHgecrl2dE-K1rVqdmo2TLmO22JU,1525
+limitguard/x402.py,sha256=UmkhPqo43v183KAvAUDbatIAAOtUAJ6IQ5JVDbsyhQ8,8504
+limitguard-0.1.0.dist-info/METADATA,sha256=5JvxubakFp8mflnnJRday_BDY516j5I9kBjkqsaLAb8,3991
+limitguard-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+limitguard-0.1.0.dist-info/licenses/LICENSE,sha256=YxjQ2QGysa2SgAXBO7C8G_ZNukmyLgNkYnogIL2betI,1082
+limitguard-0.1.0.dist-info/RECORD,,

limitguard-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

limitguard-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ambulatio Consulting B.V.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.