open-agentpay 0.2.1__tar.gz → 0.2.2__tar.gz

{open_agentpay-0.2.1 → open_agentpay-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: open-agentpay
-Version: 0.2.1
+Version: 0.2.2
 Summary: The Open-Source Payment Infrastructure & Financial Firewall for Autonomous AI Agents
 Project-URL: Homepage, https://github.com/open-agentpay/AgentPay
 Project-URL: Documentation, https://open-agentpay.github.io/AgentPay/

{open_agentpay-0.2.1 → open_agentpay-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "open-agentpay"
-version = "0.2.1"
+version = "0.2.2"
 description = "The Open-Source Payment Infrastructure & Financial Firewall for Autonomous AI Agents"
 readme = "README.md"
 license = "Apache-2.0"

{open_agentpay-0.2.1 → open_agentpay-0.2.2}/src/agentpay/__init__.py

@@ -3,7 +3,7 @@ AgentPay Python SDK
 The Open-Source Payment Infrastructure & Financial Firewall for Autonomous AI Agents.
 """
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"
 
 from agentpay.client import (
     AgentPayClient,

open_agentpay-0.2.2/src/agentpay/client/client.py

@@ -0,0 +1,170 @@
+"""
+AgentPayClient: Drop-in httpx.Client with automatic 402 payment negotiation.
+
+Wraps the financial firewall and EIP-712 cryptographic signer to automatically
+satisfy HTTP 402 Payment Required challenges.
+
+Note on ``transport=``: unlike a plain httpx.Client, the transport you pass here is the
+INNER transport. It is always wrapped by AgentPayTransport so every request passes the firewall.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+import httpx
+
+from agentpay.client.interfaces import ISigner
+from agentpay.client.transport import (
+    DEFAULT_CREDENTIAL_HEADERS,
+    DEFAULT_CREDENTIAL_VALUE_PREFIXES,
+    AgentPayTransport,
+    AsyncAgentPayTransport,
+    CredentialMode,
+)
+from agentpay.policy.interfaces import IPolicyEngine
+
+# Client kwargs that configure the default network transport. httpx only applies them when it builds
+# the transport itself; since we always inject ours, they must be forwarded to the inner transport.
+_INNER_PASSTHROUGH = ("verify", "cert", "http1", "http2", "limits", "trust_env")
+
+
+def _inner_transport_kwargs(kwargs: dict[str, Any]) -> dict[str, Any]:
+    """Collect inner-transport settings from client kwargs (mutates ``kwargs``: removes ``proxy``)."""
+    if "mounts" in kwargs or "proxies" in kwargs:
+        # httpx routes matching URLs to mounted transports BEFORE the default transport,
+        # which would skip the payment firewall entirely.
+        raise TypeError(
+            "AgentPayClient does not support 'mounts'/'proxies': they bypass the payment firewall. "
+            "Pass a pre-configured inner transport via transport=... or use proxy=..."
+        )
+    out = {k: kwargs[k] for k in _INNER_PASSTHROUGH if k in kwargs}
+    if "proxy" in kwargs:
+        # Left in kwargs, httpx would create a proxy mount that bypasses AgentPayTransport.
+        out["proxy"] = kwargs.pop("proxy")
+    return out
+
+
+class AgentPayClient(httpx.Client):
+    """
+    HTTP client for autonomous AI agents with integrated financial firewall.
+
+    Inherits from httpx.Client: fully compatible with LangChain, LlamaIndex,
+    and standard Python HTTP toolchains. Set ``wallet_challenge_mode=True`` when
+    sending AgentPay Gateway API-key requests so the first request can receive
+    a price challenge before any wallet hold is placed.
+    """
+
+    def __init__(
+            self,
+            signer: ISigner,
+            policy: IPolicyEngine,
+            *,
+            transport: httpx.BaseTransport | None = None,
+            auto_retry_on_402: bool = True,
+            raise_on_policy_rejection: bool = False,
+            clock: Callable[[], int] | None = None,
+            unmetered_credential_policy: CredentialMode = "block",
+            credential_headers: tuple[str, ...] = DEFAULT_CREDENTIAL_HEADERS,
+            credential_value_prefixes: tuple[str, ...] = DEFAULT_CREDENTIAL_VALUE_PREFIXES,
+            estimate_cost: Callable[[httpx.Request], int] | None = None,
+            actual_cost: Callable[[httpx.Response], int | None] | None = None,
+            credential_ttl_seconds: int = 60,
+            wallet_challenge_mode: bool = False,
+            **kwargs: Any,
+    ) -> None:
+        inner_kwargs = _inner_transport_kwargs(kwargs)
+
+        self.signer = signer
+        self.policy = policy
+        self.auto_retry_on_402 = auto_retry_on_402
+        self.raise_on_policy_rejection = raise_on_policy_rejection
+        self._clock = clock
+        self.unmetered_credential_policy = unmetered_credential_policy
+        # Single source of truth, reused by async_client() so both clients behave identically.
+        self._agentpay_options: dict[str, Any] = {
+            "auto_retry_on_402": auto_retry_on_402,
+            "raise_on_policy_rejection": raise_on_policy_rejection,
+            "clock": clock,
+            "unmetered_credential_policy": unmetered_credential_policy,
+            "credential_headers": credential_headers,
+            "credential_value_prefixes": credential_value_prefixes,
+            "estimate_cost": estimate_cost,
+            "actual_cost": actual_cost,
+            "credential_ttl_seconds": credential_ttl_seconds,
+            "wallet_challenge_mode": wallet_challenge_mode,
+        }
+
+        inner = transport if transport is not None else httpx.HTTPTransport(**inner_kwargs)
+        agent_transport = AgentPayTransport(inner, signer, policy, **self._agentpay_options)
+        super().__init__(transport=agent_transport, **kwargs)
+
+    def async_client(
+            self,
+            *,
+            transport: httpx.AsyncBaseTransport | None = None,
+            **kwargs: Any,
+    ) -> AsyncAgentPayClient:
+        """Create an AsyncAgentPayClient sharing the same signer, policy and firewall options."""
+        options = {**self._agentpay_options, **{k: v for k, v in kwargs.items() if k in self._agentpay_options}}
+        client_kwargs = {k: v for k, v in kwargs.items() if k not in self._agentpay_options}
+        return AsyncAgentPayClient(
+            signer=self.signer,
+            policy=self.policy,
+            transport=transport,
+            **options,
+            **client_kwargs,
+        )
+
+
+class AsyncAgentPayClient(httpx.AsyncClient):
+    """
+    Asynchronous HTTP client for autonomous AI agents with integrated financial firewall.
+
+    Inherits from httpx.AsyncClient. Use ``wallet_challenge_mode=True`` for
+    AgentPay Gateway API-key requests that must be priced before wallet payment.
+    """
+
+    def __init__(
+            self,
+            signer: ISigner,
+            policy: IPolicyEngine,
+            *,
+            transport: httpx.AsyncBaseTransport | None = None,
+            auto_retry_on_402: bool = True,
+            raise_on_policy_rejection: bool = False,
+            clock: Callable[[], int] | None = None,
+            unmetered_credential_policy: CredentialMode = "block",
+            credential_headers: tuple[str, ...] = DEFAULT_CREDENTIAL_HEADERS,
+            credential_value_prefixes: tuple[str, ...] = DEFAULT_CREDENTIAL_VALUE_PREFIXES,
+            estimate_cost: Callable[[httpx.Request], int] | None = None,
+            actual_cost: Callable[[httpx.Response], int | None] | None = None,
+            credential_ttl_seconds: int = 60,
+            wallet_challenge_mode: bool = False,
+            **kwargs: Any,
+    ) -> None:
+        inner_kwargs = _inner_transport_kwargs(kwargs)
+
+        self.signer = signer
+        self.policy = policy
+        self.auto_retry_on_402 = auto_retry_on_402
+        self.raise_on_policy_rejection = raise_on_policy_rejection
+        self._clock = clock
+        self.unmetered_credential_policy = unmetered_credential_policy
+        self._agentpay_options: dict[str, Any] = {
+            "auto_retry_on_402": auto_retry_on_402,
+            "raise_on_policy_rejection": raise_on_policy_rejection,
+            "clock": clock,
+            "unmetered_credential_policy": unmetered_credential_policy,
+            "credential_headers": credential_headers,
+            "credential_value_prefixes": credential_value_prefixes,
+            "estimate_cost": estimate_cost,
+            "actual_cost": actual_cost,
+            "credential_ttl_seconds": credential_ttl_seconds,
+            "wallet_challenge_mode": wallet_challenge_mode,
+        }
+
+        inner = transport if transport is not None else httpx.AsyncHTTPTransport(**inner_kwargs)
+        agent_transport = AsyncAgentPayTransport(inner, signer, policy, **self._agentpay_options)
+        super().__init__(transport=agent_transport, **kwargs)

{open_agentpay-0.2.1 → open_agentpay-0.2.2}/src/agentpay/client/transport.py

@@ -2,7 +2,7 @@
 httpx transparent 402 interceptor transports for AgentPay.
 
 Implements the autonomous financial lifecycle:
-  Intercept 402 -> Policy Evaluate & Reserve -> Sign Authorization -> Replay with PAYMENT-SIGNATURE -> Commit or Hold
+  Intercept 402 -> Policy Evaluate & Reserve -> Sign or authorize -> Replay with PAYMENT-SIGNATURE -> Commit or Hold
 
 Adheres strictly to CLAUDE.md safety rules:
   - Fail-closed evaluation
@@ -21,11 +21,17 @@ answered 200 without any 402-round trip, which would bypass the local firewall.
   "allow" legacy behaviour, firewall is bypassed (explicit opt-in only)
 
 A single request can opt out with ``extensions={"agentpay_allow_unmetered": True}``.
+
+For AgentPay Gateway virtual wallets, ``wallet_challenge_mode=True`` bypasses the
+pre-request credential meter so the gateway can return a price challenge first;
+the challenge is then evaluated locally before the authorized retry is sent.
 """
 
 from __future__ import annotations
 
+import hashlib
 import logging
+import secrets
 import time
 import uuid
 from collections.abc import Callable
@@ -35,10 +41,11 @@ import httpx
 
 from agentpay.client.interfaces import ISigner
 from agentpay.core.codecs import (
+    encode_wallet_authorization,
     extract_challenge_from_headers,
     inject_authorization_to_headers,
 )
-from agentpay.core.models import PaymentAuthorization
+from agentpay.core.models import PaymentAuthorization, WalletAuthorization
 from agentpay.policy.errors import PolicyErrorCode, PolicyViolationError
 from agentpay.policy.interfaces import IPolicyEngine
 from agentpay.policy.metered import IMeteredPolicyEngine
@@ -117,6 +124,7 @@ class _AgentPayCore:
             estimate_cost: Callable[[httpx.Request], int] | None,
             actual_cost: Callable[[httpx.Response], int | None] | None,
             credential_ttl_seconds: int,
+            wallet_challenge_mode: bool,
     ) -> None:
         if unmetered_credential_policy not in ("block", "meter", "allow"):
             raise ValueError(
@@ -137,6 +145,7 @@ class _AgentPayCore:
         self._estimate_cost = estimate_cost
         self._actual_cost = actual_cost
         self._cred_ttl = credential_ttl_seconds
+        self._wallet_challenge_mode = wallet_challenge_mode
 
     # -- credential-mode ---------------------------------------------------
 
@@ -154,6 +163,10 @@ class _AgentPayCore:
 
     def _meter_begin(self, request: httpx.Request) -> str | None:
         """Runs BEFORE the request is sent. Returns an intent id if a metered reservation was taken."""
+        # This opt-in is only for AgentPay Gateway wallet routes: the first call must reach
+        # the gateway to obtain its price challenge, which is then policy-checked below.
+        if self._wallet_challenge_mode and self._has_credential(request):
+            return None
         if request.extensions.get(ALLOW_UNMETERED_EXTENSION) or not self._has_credential(request):
             return None
         if self._cred_mode == "allow":
@@ -211,8 +224,20 @@ class _AgentPayCore:
             return None  # not a compliant x402 challenge
         if challenge.is_expired(self._clock()):
             return None
+        if challenge.scheme not in ("EIP-3009", "agentpay-wallet"):
+            raise PolicyViolationError(PolicyErrorCode.POLICY_SYSTEM_ERROR, f"unsupported payment scheme: {challenge.scheme}")
+        if challenge.scheme == "agentpay-wallet":
+            expected_binding = self._request_binding(request)
+            if (challenge.extensions or {}).get("requestBinding") != expected_binding:
+                raise PolicyViolationError(PolicyErrorCode.POLICY_SYSTEM_ERROR, "wallet challenge requestBinding mismatch")
+            if not (challenge.extensions or {}).get("routeId"):
+                raise PolicyViolationError(PolicyErrorCode.POLICY_SYSTEM_ERROR, "wallet challenge missing routeId")
+            raw_path, _, _ = request.url.raw_path.partition(b"?")
+            if challenge.resource_uri != (raw_path.decode("ascii") or "/"):
+                raise PolicyViolationError(PolicyErrorCode.POLICY_SYSTEM_ERROR, "wallet challenge resourceUri mismatch")
 
         payment_request = challenge.to_payment_request(domain=request.url.host)
+        # SECURITY-REVIEW: reserve the exact seller challenge amount before generating wallet authorization.
         decision = self._policy.reserve(
             intent_id=payment_request.intent_id,
             amount=payment_request.amount,
@@ -231,19 +256,58 @@ class _AgentPayCore:
             raise PolicyViolationError(PolicyErrorCode.POLICY_SYSTEM_ERROR, "approved decision without reservation")
         return challenge, decision.reservation
 
+    @staticmethod
+    def _request_binding(request: httpx.Request) -> str:
+        """Match the Go Gateway's method/path/query/body SHA-256 canonicalization."""
+        raw_path, marker, raw_query = request.url.raw_path.partition(b"?")
+        path = raw_path.decode("ascii") or "/"
+        query = raw_query.decode("ascii") if marker else ""
+        body_digest = hashlib.sha256(request.read()).hexdigest()
+        canonical = f"{request.method.upper()}\n{path}\n{query}\n{body_digest}".encode("utf-8")
+        return "sha256:" + hashlib.sha256(canonical).hexdigest()
+
     def _sign_and_clone(self, request: httpx.Request, challenge: Any, reservation: Any) -> httpx.Request:
         # Everything here happens BEFORE transmission, so releasing on failure is safe.
         try:
+            if challenge.scheme == "agentpay-wallet":
+                # SECURITY-REVIEW: the challenge-bound reservation is the buyer-side approval gate.
+                if reservation.intent_id != challenge.challenge_id or reservation.amount != challenge.amount_base_units:
+                    raise PolicyViolationError(PolicyErrorCode.POLICY_SYSTEM_ERROR, "wallet reservation does not match challenge")
+                if reservation.expires_at < challenge.valid_before:
+                    raise PolicyViolationError(PolicyErrorCode.POLICY_SYSTEM_ERROR, "wallet reservation expires before challenge")
+                request_binding = (challenge.extensions or {}).get("requestBinding")
+                if not request_binding:
+                    raise PolicyViolationError(PolicyErrorCode.POLICY_SYSTEM_ERROR, "wallet challenge missing requestBinding")
+                wallet_auth = WalletAuthorization(
+                    challengeId=challenge.challenge_id,
+                    nonce="0x" + secrets.token_bytes(32).hex(),
+                    validAfter=challenge.valid_after,
+                    validBefore=challenge.valid_before,
+                    amount=challenge.amount,
+                    resourceUri=challenge.resource_uri,
+                    requestBinding=request_binding,
+                )
+                headers = httpx.Headers(request.headers)
+                headers["PAYMENT-SIGNATURE"] = encode_wallet_authorization(wallet_auth)
+                content = request.read()
+                return httpx.Request(
+                    method=request.method, url=request.url, headers=headers,
+                    content=content, extensions=dict(request.extensions),
+                )
             authorization = self._signer.sign_payment_authorization(challenge, reservation)
             return _clone_request_with_authorization(request, authorization)
         except Exception:
             self._policy.release(reservation.intent_id)
             raise
 
-    def _settle_x402(self, intent_id: str, retry_response: httpx.Response) -> None:
+    def _settle_x402(self, intent_id: str, retry_response: httpx.Response, scheme: str) -> None:
         code = retry_response.status_code
+        # SECURITY-REVIEW: only a definitive wallet 4xx releases; ambiguous and 5xx outcomes stay reserved.
         if 200 <= code < 300:
             self._policy.commit(intent_id)
+        elif scheme == "agentpay-wallet" and 400 <= code < 500:
+            # Wallet authorization has no chain signature; a definitive gateway rejection means no hold was dispatched.
+            self._policy.release(intent_id)
         elif code >= 500:
             # Signature is on the wire: keep RESERVED (no auto release) and feed the breaker.
             _safe_record_failure(self._policy, f"upstream {code} after payment")
@@ -259,8 +323,8 @@ class AgentPayTransport(_AgentPayCore, httpx.BaseTransport):
     Synchronous httpx transport interceptor for AgentPay.
 
     Transparently catches HTTP 402 Payment Required responses, evaluates the
-    challenge against the local policy firewall, signs with EIP-712/3009,
-    and replays the request with payment credentials.
+    challenge against the local policy firewall, then either signs EIP-3009 or
+    creates an AgentPay wallet authorization before replaying the request.
     """
 
     def __init__(
@@ -278,6 +342,7 @@ class AgentPayTransport(_AgentPayCore, httpx.BaseTransport):
             estimate_cost: Callable[[httpx.Request], int] | None = None,
             actual_cost: Callable[[httpx.Response], int | None] | None = None,
             credential_ttl_seconds: int = 60,
+            wallet_challenge_mode: bool = False,
     ) -> None:
         httpx.BaseTransport.__init__(self)
         _AgentPayCore.__init__(
@@ -293,6 +358,7 @@ class AgentPayTransport(_AgentPayCore, httpx.BaseTransport):
             estimate_cost=estimate_cost,
             actual_cost=actual_cost,
             credential_ttl_seconds=credential_ttl_seconds,
+            wallet_challenge_mode=wallet_challenge_mode,
         )
         self._inner_transport = inner_transport
 
@@ -311,6 +377,13 @@ class AgentPayTransport(_AgentPayCore, httpx.BaseTransport):
         if meter_id is not None:
             self._meter_end(meter_id, response)
 
+        if self._wallet_challenge_mode and self._has_credential(request) and 200 <= response.status_code < 300:
+            response.close()
+            raise PolicyViolationError(
+                PolicyErrorCode.UNMETERED_CREDENTIAL,
+                "Wallet challenge mode expected a 402 price challenge; the gateway served the credential request directly.",
+            )
+
         if response.status_code != 402 or not self._auto_retry:
             return response
 
@@ -329,7 +402,7 @@ class AgentPayTransport(_AgentPayCore, httpx.BaseTransport):
             _safe_record_failure(self._policy, "transport error after payment signature sent")
             raise
 
-        self._settle_x402(reservation.intent_id, retry_response)
+        self._settle_x402(reservation.intent_id, retry_response, challenge.scheme)
         return retry_response
 
 
@@ -356,6 +429,7 @@ class AsyncAgentPayTransport(_AgentPayCore, httpx.AsyncBaseTransport):
             estimate_cost: Callable[[httpx.Request], int] | None = None,
             actual_cost: Callable[[httpx.Response], int | None] | None = None,
             credential_ttl_seconds: int = 60,
+            wallet_challenge_mode: bool = False,
     ) -> None:
         httpx.AsyncBaseTransport.__init__(self)
         _AgentPayCore.__init__(
@@ -371,6 +445,7 @@ class AsyncAgentPayTransport(_AgentPayCore, httpx.AsyncBaseTransport):
             estimate_cost=estimate_cost,
             actual_cost=actual_cost,
             credential_ttl_seconds=credential_ttl_seconds,
+            wallet_challenge_mode=wallet_challenge_mode,
         )
         self._inner_transport = inner_transport
 
@@ -388,6 +463,13 @@ class AsyncAgentPayTransport(_AgentPayCore, httpx.AsyncBaseTransport):
         if meter_id is not None:
             self._meter_end(meter_id, response)
 
+        if self._wallet_challenge_mode and self._has_credential(request) and 200 <= response.status_code < 300:
+            await response.aclose()
+            raise PolicyViolationError(
+                PolicyErrorCode.UNMETERED_CREDENTIAL,
+                "Wallet challenge mode expected a 402 price challenge; the gateway served the credential request directly.",
+            )
+
         if response.status_code != 402 or not self._auto_retry:
             return response
 
@@ -405,5 +487,5 @@ class AsyncAgentPayTransport(_AgentPayCore, httpx.AsyncBaseTransport):
             _safe_record_failure(self._policy, "transport error after payment signature sent")
             raise
 
-        self._settle_x402(reservation.intent_id, retry_response)
+        self._settle_x402(reservation.intent_id, retry_response, challenge.scheme)
         return retry_response

{open_agentpay-0.2.1/src/agentpay/protocol → open_agentpay-0.2.2/src/agentpay/core}/codecs.py

@@ -23,7 +23,7 @@ from agentpay.core.errors import (
     X402ErrorCode,
     X402ValidationError,
 )
-from agentpay.core.models import PaymentAuthorization, PaymentChallenge
+from agentpay.core.models import PaymentAuthorization, PaymentChallenge, WalletAuthorization
 
 # Standard HTTP Header Constants (RFC-compliant uppercase default)
 HEADER_PAYMENT_REQUIRED = "PAYMENT-REQUIRED"
@@ -176,6 +176,15 @@ def encode_authorization(authorization: PaymentAuthorization, *, base64_url: boo
         ) from exc
 
 
+def encode_wallet_authorization(authorization: WalletAuthorization, *, base64_url: bool = True) -> str:
+    """Encode AgentPay's non-EIP-3009 wallet authorization in PAYMENT-SIGNATURE."""
+    try:
+        payload = authorization.model_dump_json(by_alias=True, exclude_none=True)
+        return base64url_encode(payload.encode("utf-8")) if base64_url else payload
+    except Exception as exc:  # noqa: BLE001
+        raise X402EncodeError("Failed to encode wallet authorization", code=X402ErrorCode.MALFORMED_HEADER) from exc
+
+
 def decode_authorization(header_value: str) -> PaymentAuthorization:
     """
     Decode an HTTP PAYMENT-SIGNATURE header value (Base64URL or raw JSON) into a PaymentAuthorization model.

{open_agentpay-0.2.1/src/agentpay/protocol → open_agentpay-0.2.2/src/agentpay/core}/models.py

@@ -146,21 +146,22 @@ class PaymentChallenge(BaseModel):
     Corresponds to the PAYMENT-REQUIRED header.
     """
 
-    model_config = ConfigDict(frozen=True, populate_by_name=True)
+    model_config = ConfigDict(frozen=True, populate_by_name=True, extra="allow")
 
     version: str = Field(default="2.0", description="Protocol version, fixed to 2.0")
     challenge_id: str = Field(..., alias="challengeId", description="Globally unique challenge ID")
-    network: str = Field(..., description="CAIP-2 formatted network identifier")
-    asset: str = Field(..., description="Payment token contract address (EVM 0x format)")
+    scheme: str = Field(default="EIP-3009", description="Payment authorization scheme")
+    network: str | None = Field(default=None, description="CAIP-2 network or AgentPay internal ledger")
+    asset: str | None = Field(default=None, description="Payment asset identifier")
     asset_symbol: str | None = Field(default=None, alias="assetSymbol", description="Token symbol")
     decimals: int = Field(default=6, description="Token decimals")
     amount: str = Field(..., description="Payment amount in integer base units as string")
-    payee: str = Field(..., description="Recipient address on-chain (EVM 0x format)")
-    scheme: str = Field(default="EIP-3009", description="Payment authorization scheme")
+    payee: str | None = Field(default=None, description="Chain recipient or AgentPay route resource")
     valid_after: int = Field(..., alias="validAfter", description="Unix timestamp valid after (seconds)")
     valid_before: int = Field(..., alias="validBefore", description="Unix timestamp valid before (seconds)")
-    facilitator_url: str = Field(..., alias="facilitatorUrl", description="Facilitator clearing endpoint URL")
+    facilitator_url: str | None = Field(default=None, alias="facilitatorUrl", description="Facilitator clearing endpoint URL")
     resource_uri: str | None = Field(default=None, alias="resourceUri", description="Protected resource path")
+    extensions: dict[str, Any] | None = None
 
     def __init__(self, /, **data: Any) -> None:
         try:
@@ -217,17 +218,29 @@ class PaymentChallenge(BaseModel):
 
     @field_validator("network")
     @classmethod
-    def _validate_network(cls, v: str) -> str:
+    def _validate_network(cls, v: str | None, info: Any) -> str | None:
+        if info.data.get("scheme") == "agentpay-wallet" and v == "agentpay:internal-ledger":
+            return v
+        if v is None:
+            raise X402ValidationError("network is required", code=X402ErrorCode.MISSING_REQUIRED_FIELD)
         return _validate_caip2(v)
 
     @field_validator("asset")
     @classmethod
-    def _validate_asset(cls, v: str) -> str:
+    def _validate_asset(cls, v: str | None, info: Any) -> str | None:
+        if info.data.get("scheme") == "agentpay-wallet" and v == "USD":
+            return v
+        if v is None:
+            raise X402ValidationError("asset is required", code=X402ErrorCode.MISSING_REQUIRED_FIELD)
         return _validate_evm_address(v, "asset")
 
     @field_validator("payee")
     @classmethod
-    def _validate_payee(cls, v: str) -> str:
+    def _validate_payee(cls, v: str | None, info: Any) -> str | None:
+        if info.data.get("scheme") == "agentpay-wallet" and v and v.startswith("agentpay:route:"):
+            return v
+        if v is None:
+            raise X402ValidationError("payee is required", code=X402ErrorCode.MISSING_REQUIRED_FIELD)
         return _validate_evm_address(v, "payee")
 
     @field_validator("decimals")
@@ -315,6 +328,17 @@ class PaymentChallenge(BaseModel):
             )
         return self
 
+    @model_validator(mode="after")
+    def _validate_scheme_fields(self) -> PaymentChallenge:
+        if self.scheme == "agentpay-wallet":
+            if self.network != "agentpay:internal-ledger" or self.asset != "USD" or not self.resource_uri:
+                raise X402ValidationError("invalid agentpay-wallet challenge fields", code=X402ErrorCode.INVALID_SCHEME)
+            if self.facilitator_url:
+                raise X402ValidationError("agentpay-wallet challenge must not name an EIP-3009 facilitator", code=X402ErrorCode.INVALID_SCHEME)
+        elif not self.network or not self.asset or not self.payee or not self.facilitator_url:
+            raise X402ValidationError("EIP-3009 challenge requires network, asset, payee, and facilitatorUrl", code=X402ErrorCode.MISSING_REQUIRED_FIELD)
+        return self
+
     @property
     def amount_base_units(self) -> int:
         """Payment amount parsed into integer base units."""
@@ -341,9 +365,9 @@ class PaymentChallenge(BaseModel):
         return PaymentRequest(
             intent_id=intent_id or self.challenge_id,
             amount=self.amount_base_units,
-            payee=self.payee,
-            asset=self.asset,
-            network=self.network,
+            payee=self.payee or "agentpay:route:unknown",
+            asset=self.asset or "USD",
+            network=self.network or "agentpay:internal-ledger",
             domain=domain,
             ttl_seconds=ttl_seconds,
         )
@@ -460,3 +484,41 @@ class PaymentAuthorization(BaseModel):
                 code=X402ErrorCode.INVALID_TIME_WINDOW,
             )
         return self
+
+
+class WalletAuthorization(BaseModel):
+    """AgentPay's API-key-authenticated wallet approval payload (not a cryptographic signature)."""
+
+    model_config = ConfigDict(frozen=True, populate_by_name=True)
+
+    version: str = "2.0"
+    challenge_id: str = Field(..., alias="challengeId")
+    scheme: str = "agentpay-wallet"
+    nonce: str
+    valid_after: int = Field(..., alias="validAfter")
+    valid_before: int = Field(..., alias="validBefore")
+    amount: str
+    resource_uri: str = Field(..., alias="resourceUri")
+    request_binding: str = Field(..., alias="requestBinding")
+
+    @field_validator("nonce")
+    @classmethod
+    def _validate_wallet_nonce(cls, value: str) -> str:
+        if not re.fullmatch(r"0x[0-9a-f]{64}", value):
+            raise X402ValidationError("wallet nonce must be 32 random bytes encoded as lowercase hex", code=X402ErrorCode.INVALID_NONCE)
+        return value
+
+    @field_validator("amount")
+    @classmethod
+    def _validate_wallet_amount(cls, value: str) -> str:
+        if not value.isdecimal() or int(value) <= 0 or int(value) > SQLITE_MAX_INT:
+            raise X402ValidationError("wallet amount must be a positive int64 decimal string", code=X402ErrorCode.INVALID_AMOUNT_FORMAT)
+        return value
+
+    @model_validator(mode="after")
+    def _validate_wallet_fields(self) -> WalletAuthorization:
+        if self.version != "2.0" or self.scheme != "agentpay-wallet" or self.valid_before <= self.valid_after:
+            raise X402ValidationError("invalid agentpay-wallet authorization fields", code=X402ErrorCode.INVALID_SCHEME)
+        if not self.challenge_id or not self.resource_uri or not re.fullmatch(r"sha256:[0-9a-f]{64}", self.request_binding):
+            raise X402ValidationError("wallet authorization is missing challenge binding fields", code=X402ErrorCode.MISSING_REQUIRED_FIELD)
+        return self

{open_agentpay-0.2.1 → open_agentpay-0.2.2}/src/agentpay/policy/models.py

@@ -199,7 +199,13 @@ class PolicyConfig(BaseModel):
         for addr in v:
             if not isinstance(addr, str):
                 raise TypeError(f"whitelist_payees elements must be strings, got {type(addr).__name__}")
-        return frozenset(_validate_evm_address(addr, "whitelist_payees") for addr in v)
+        normalized: list[str] = []
+        for addr in v:
+            if addr.startswith("agentpay:route:") and len(addr) > len("agentpay:route:"):
+                normalized.append(addr)
+            else:
+                normalized.append(_validate_evm_address(addr, "whitelist_payees"))
+        return frozenset(normalized)
 
     @field_validator("whitelist_assets", mode="before")
     @classmethod
@@ -211,7 +217,10 @@ class PolicyConfig(BaseModel):
         for addr in v:
             if not isinstance(addr, str):
                 raise TypeError(f"whitelist_assets elements must be strings, got {type(addr).__name__}")
-        return frozenset(_validate_evm_address(addr, "whitelist_assets") for addr in v)
+        normalized: list[str] = []
+        for addr in v:
+            normalized.append("USD" if addr == "USD" else _validate_evm_address(addr, "whitelist_assets"))
+        return frozenset(normalized)
 
     @field_validator("whitelist_networks", mode="before")
     @classmethod

open_agentpay-0.2.1/src/agentpay/client/client.py

@@ -1,109 +0,0 @@
-"""
-AgentPayClient: Drop-in httpx.Client with automatic 402 payment negotiation.
-
-Wraps the financial firewall and EIP-712 cryptographic signer to automatically
-satisfy HTTP 402 Payment Required challenges.
-"""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from typing import Any
-
-import httpx
-
-from agentpay.client.interfaces import ISigner
-from agentpay.client.transport import AgentPayTransport, AsyncAgentPayTransport
-from agentpay.policy.interfaces import IPolicyEngine
-
-
-class AgentPayClient(httpx.Client):
-    """
-    HTTP client for autonomous AI agents with integrated financial firewall.
-
-    Inherits from httpx.Client: fully compatible with LangChain, LlamaIndex,
-    and standard Python HTTP toolchains.
-    """
-
-    def __init__(
-        self,
-        signer: ISigner,
-        policy: IPolicyEngine,
-        *,
-        transport: httpx.BaseTransport | None = None,
-        auto_retry_on_402: bool = True,
-        raise_on_policy_rejection: bool = False,
-        clock: Callable[[], int] | None = None,
-        **kwargs: Any,
-    ) -> None:
-        self.signer = signer
-        self.policy = policy
-        self.auto_retry_on_402 = auto_retry_on_402
-        self.raise_on_policy_rejection = raise_on_policy_rejection
-        self._clock = clock
-
-        inner = transport or httpx.HTTPTransport()
-        agent_transport = AgentPayTransport(
-            inner_transport=inner,
-            signer=signer,
-            policy=policy,
-            auto_retry_on_402=auto_retry_on_402,
-            raise_on_policy_rejection=raise_on_policy_rejection,
-            clock=clock,
-        )
-
-        super().__init__(transport=agent_transport, **kwargs)
-
-    def async_client(
-        self,
-        *,
-        transport: httpx.AsyncBaseTransport | None = None,
-        **kwargs: Any,
-    ) -> AsyncAgentPayClient:
-        """Create an asynchronous AsyncAgentPayClient sharing the same signer and policy."""
-        return AsyncAgentPayClient(
-            signer=self.signer,
-            policy=self.policy,
-            transport=transport,
-            auto_retry_on_402=self.auto_retry_on_402,
-            raise_on_policy_rejection=self.raise_on_policy_rejection,
-            clock=self._clock,
-            **kwargs,
-        )
-
-
-class AsyncAgentPayClient(httpx.AsyncClient):
-    """
-    Asynchronous HTTP client for autonomous AI agents with integrated financial firewall.
-
-    Inherits from httpx.AsyncClient.
-    """
-
-    def __init__(
-        self,
-        signer: ISigner,
-        policy: IPolicyEngine,
-        *,
-        transport: httpx.AsyncBaseTransport | None = None,
-        auto_retry_on_402: bool = True,
-        raise_on_policy_rejection: bool = False,
-        clock: Callable[[], int] | None = None,
-        **kwargs: Any,
-    ) -> None:
-        self.signer = signer
-        self.policy = policy
-        self.auto_retry_on_402 = auto_retry_on_402
-        self.raise_on_policy_rejection = raise_on_policy_rejection
-        self._clock = clock
-
-        inner = transport or httpx.AsyncHTTPTransport()
-        agent_transport = AsyncAgentPayTransport(
-            inner_transport=inner,
-            signer=signer,
-            policy=policy,
-            auto_retry_on_402=auto_retry_on_402,
-            raise_on_policy_rejection=raise_on_policy_rejection,
-            clock=clock,
-        )
-
-        super().__init__(transport=agent_transport, **kwargs)