mcp-server-agentpay 0.1.0__py3-none-any.whl

agentpay/__init__.py

@@ -0,0 +1,3 @@
+"""AgentPay — Agent-to-Agent micropayments via x402 + MCP."""
+
+__version__ = "0.1.0"

agentpay/client/http_client.py

@@ -0,0 +1,208 @@
+"""Autonomous x402 payment HTTP client for AI agents."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+import httpx
+
+from agentpay.config import Settings, get_settings
+from agentpay.payment.verifier import create_demo_payment_signature
+
+logger = logging.getLogger(__name__)
+
+
+class PaymentPolicyError(Exception):
+    """Raised when a payment exceeds agent spending policy."""
+
+
+class X402PaymentRequired(Exception):
+    """Raised when 402 is received but auto-pay is disabled."""
+
+    def __init__(self, challenge: dict[str, Any], headers: dict[str, str]):
+        self.challenge = challenge
+        self.headers = headers
+        super().__init__("Payment required")
+
+
+class X402AgentClient:
+    """
+    HTTP client that intercepts 402 Payment Required responses,
+    signs payment authorization, and automatically retries.
+    """
+
+    def __init__(self, settings: Settings | None = None):
+        self.settings = settings or get_settings()
+        self._payer_address: str | None = None
+
+    @property
+    def payer_address(self) -> str:
+        if self._payer_address:
+            return self._payer_address
+
+        if self.settings.agent_private_key:
+            try:
+                from eth_account import Account
+
+                account = Account.from_key(self.settings.agent_private_key)
+                self._payer_address = account.address
+                return self._payer_address
+            except Exception as e:
+                logger.warning("Invalid agent private key: %s", e)
+
+        self._payer_address = "0xAgentDemoWallet000000000000000000000001"
+        return self._payer_address
+
+    def _check_spending_policy(self, amount_str: str) -> None:
+        amount = float(str(amount_str).lstrip("$"))
+        if amount > self.settings.max_spend_per_call:
+            raise PaymentPolicyError(
+                f"Payment {amount} USDC exceeds max_spend_per_call "
+                f"({self.settings.max_spend_per_call} USDC)"
+            )
+
+    def _sign_demo_payment(self, challenge: dict[str, Any]) -> str:
+        amount = challenge.get("amount") or self.settings.payment_amount
+        recipient = challenge.get("recipient") or self.settings.wallet_recipient_address
+        self._check_spending_policy(str(amount))
+        sig = create_demo_payment_signature(
+            payer=self.payer_address,
+            amount=str(amount).lstrip("$"),
+            recipient=recipient,
+        )
+        logger.info("Demo payment signed: %s USDC -> %s", amount, recipient[:10])
+        return sig
+
+    async def request(
+        self,
+        method: str,
+        url: str,
+        *,
+        params: dict[str, Any] | None = None,
+        auto_pay: bool = True,
+        **kwargs: Any,
+    ) -> httpx.Response:
+        """Make HTTP request with automatic 402 handling."""
+        if not self.settings.is_demo_mode:
+            return await self._request_official_x402(
+                method, url, params=params, auto_pay=auto_pay, **kwargs
+            )
+
+        async with httpx.AsyncClient(timeout=90.0) as client:
+            response = await client.request(method, url, params=params, **kwargs)
+
+            if response.status_code != 402:
+                return response
+
+            if not auto_pay:
+                raise X402PaymentRequired(response.json(), dict(response.headers))
+
+            challenge = response.json()
+            amount = (
+                challenge.get("amount")
+                or response.headers.get("X-Payment-Amount")
+                or self.settings.payment_amount
+            )
+            challenge["amount"] = amount
+            challenge["recipient"] = (
+                challenge.get("recipient")
+                or response.headers.get("X-Payment-Recipient")
+                or self.settings.wallet_recipient_address
+            )
+
+            signature = self._sign_demo_payment(challenge)
+            headers = kwargs.pop("headers", {}) or {}
+            headers["X-Payment-Signature"] = signature
+            headers["X-Payment-Payer"] = self.payer_address
+
+            logger.info("Retrying paid request to %s", url)
+            return await client.request(method, url, params=params, headers=headers, **kwargs)
+
+    async def _request_official_x402(
+        self,
+        method: str,
+        url: str,
+        *,
+        params: dict[str, Any] | None = None,
+        auto_pay: bool = True,
+        **kwargs: Any,
+    ) -> httpx.Response:
+        """Production path: official x402 SDK signs + facilitator settles."""
+        if not self.settings.agent_private_key:
+            raise ValueError("AGENT_PRIVATE_KEY required for production x402 payments")
+
+        from eth_account import Account
+        from x402 import x402Client
+        from x402.http.clients.httpx import x402HttpxClient
+        from x402.mechanisms.evm.exact import ExactEvmScheme
+        from x402.mechanisms.evm.signers import EthAccountSigner
+
+        self._check_spending_policy(self.settings.payment_amount)
+
+        account = Account.from_key(self.settings.agent_private_key)
+        self._payer_address = account.address
+        signer = EthAccountSigner(account)
+
+        payment_client = x402Client()
+        payment_client.register(self.settings.payment_network, ExactEvmScheme(signer))
+        # Also register wildcard for network matching quirks
+        payment_client.register("eip155:*", ExactEvmScheme(signer))
+
+        if not auto_pay:
+            async with httpx.AsyncClient(timeout=90.0) as client:
+                response = await client.request(method, url, params=params, **kwargs)
+                if response.status_code == 402:
+                    raise X402PaymentRequired(
+                        response.json() if response.content else {},
+                        dict(response.headers),
+                    )
+                return response
+
+        async with x402HttpxClient(payment_client, timeout=90.0) as client:
+            response = await client.request(method, url, params=params, **kwargs)
+            return response
+
+    async def get_sourcing(
+        self,
+        keyword: str,
+        category_id: str | None = None,
+        max_price: float | None = None,
+    ) -> dict[str, Any]:
+        settings = self.settings
+        url = f"{settings.gateway_base_url}/api/v1/paid/sourcing"
+        params: dict[str, Any] = {"keyword": keyword}
+        if category_id:
+            params["category_id"] = category_id
+        if max_price is not None:
+            params["max_price"] = max_price
+
+        response = await self.request("GET", url, params=params)
+        response.raise_for_status()
+        return response.json()
+
+    async def get_xhs_note(
+        self,
+        note: str,
+        note_type: str | None = None,
+    ) -> dict[str, Any]:
+        url = f"{self.settings.gateway_base_url}/api/v1/paid/xhs/note"
+        params: dict[str, Any] = {"note": note}
+        if note_type:
+            params["note_type"] = note_type
+        response = await self.request("GET", url, params=params)
+        response.raise_for_status()
+        return response.json()
+
+    async def get_xhs_user_notes(
+        self,
+        user_id: str,
+        cursor: str = "",
+    ) -> dict[str, Any]:
+        url = f"{self.settings.gateway_base_url}/api/v1/paid/xhs/user_notes"
+        params: dict[str, Any] = {"user_id": user_id}
+        if cursor:
+            params["cursor"] = cursor
+        response = await self.request("GET", url, params=params)
+        response.raise_for_status()
+        return response.json()

agentpay/config.py

@@ -0,0 +1,68 @@
+"""Central configuration loaded from environment variables."""
+
+from functools import lru_cache
+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+# Well-known USDC contract addresses
+USDC_BASE_MAINNET = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+USDC_BASE_SEPOLIA = "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    # Gateway
+    wallet_recipient_address: str = "0x5f29e616e34bf86dD72B622Ef392b2FDcF1Aa50E"
+    payment_network: str = "eip155:8453"  # Base Mainnet; use eip155:84532 for Sepolia test
+    payment_amount: str = "0.05"
+    payment_token_address: str = USDC_BASE_MAINNET
+    gateway_host: str = "127.0.0.1"
+    gateway_port: int = 8402
+    gateway_base_url: str = "http://127.0.0.1:8402"
+
+    # demo = local fake pay | production = official x402 facilitator settle
+    payment_mode: str = "demo"
+    base_rpc_url: str = "https://mainnet.base.org"
+
+    # Agent client
+    agent_private_key: str = ""
+    max_spend_per_call: float = 0.10
+
+    # Optional override; default picks testnet vs mainnet facilitator
+    x402_facilitator_url: str = ""
+
+    # Xiaohongshu data providers (gateway-side secrets only)
+    dataflow_base_url: str = "https://dataflowserver.org"
+    dataflow_api_token: str = ""
+    tikhub_api_key: str = ""
+
+    # Operator debug only — agents should always pay the gateway
+    xhs_direct_mode: bool = False
+
+    @property
+    def payment_token_symbol(self) -> str:
+        return "USDC"
+
+    @property
+    def is_demo_mode(self) -> bool:
+        return self.payment_mode.lower() == "demo"
+
+    @property
+    def is_testnet(self) -> bool:
+        return "84532" in self.payment_network
+
+    @property
+    def has_xhs_credentials(self) -> bool:
+        return bool(
+            (self.dataflow_api_token or "").strip() or (self.tikhub_api_key or "").strip()
+        )
+
+
+@lru_cache
+def get_settings() -> Settings:
+    return Settings()

agentpay/gateway/app.py

@@ -0,0 +1,207 @@
+"""AgentPay x402 Micropayment Data Gateway — FastAPI application."""
+
+from __future__ import annotations
+
+import logging
+from contextlib import asynccontextmanager
+
+import uvicorn
+from fastapi import FastAPI, Query
+from fastapi.middleware.cors import CORSMiddleware
+
+from agentpay.config import get_settings
+from agentpay.gateway.data import query_wholesale_pricing
+from agentpay.gateway.middleware import X402PaymentMiddleware
+from agentpay.mcp_server.server import mcp as mcp_server
+from agentpay.payment.x402_setup import build_paid_routes, build_resource_server, settlement_info
+from agentpay.xhs.fetcher import fetch_note_detail, fetch_user_notes
+
+logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")
+logger = logging.getLogger(__name__)
+
+
+def create_app() -> FastAPI:
+    settings = get_settings()
+
+    # Remote MCP (Streamable HTTP) for Smithery / Glama connectors
+    mcp_http = mcp_server.streamable_http_app(
+        streamable_http_path="/",
+        stateless_http=True,
+        host="0.0.0.0",
+    )
+
+    @asynccontextmanager
+    async def lifespan(_app: FastAPI):
+        async with mcp_http.router.lifespan_context(mcp_http):
+            logger.info("MCP Streamable HTTP mounted at /mcp")
+            yield
+
+    app = FastAPI(
+        title="AgentPay x402 Gateway",
+        description=(
+            "Monetized API gateway with HTTP 402 micropayment enforcement. "
+            "Agents pay USDC on Base per request for Xiaohongshu note data and other premium APIs. "
+            "Also exposes MCP tools at /mcp (Streamable HTTP)."
+        ),
+        version="0.1.0",
+        lifespan=lifespan,
+    )
+    app.mount("/mcp", mcp_http)
+
+    # Railway/Fly terminate TLS; trust X-Forwarded-* so 402 resource URLs are https://
+    from uvicorn.middleware.proxy_headers import ProxyHeadersMiddleware
+
+    app.add_middleware(ProxyHeadersMiddleware, trusted_hosts="*")
+
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_methods=["*"],
+        allow_headers=["*"],
+        expose_headers=[
+            "X-Payment-Required",
+            "X-Payment-Network",
+            "X-Payment-Token",
+            "X-Payment-Amount",
+            "X-Payment-Recipient",
+            "X-Payment-Verified",
+            "X-Payment-Payer",
+            "PAYMENT-REQUIRED",
+            "PAYMENT-RESPONSE",
+        ],
+    )
+
+    if settings.is_demo_mode:
+        # Local/dev: accept demo signatures (no on-chain settlement)
+        app.add_middleware(X402PaymentMiddleware, settings=settings)
+        logger.info("Payment middleware: demo (no chain settlement)")
+    else:
+        # Production/testnet: official x402 verify + settle via facilitator
+        from x402.http.middleware.fastapi import PaymentMiddlewareASGI
+
+        server = build_resource_server(settings)
+        routes = build_paid_routes(settings)
+        app.add_middleware(PaymentMiddlewareASGI, routes=routes, server=server)
+        logger.info(
+            "Payment middleware: x402 facilitator=%s network=%s pay_to=%s",
+            settlement_info(settings)["facilitator"],
+            settings.payment_network,
+            settings.wallet_recipient_address,
+        )
+
+    @app.get("/health")
+    async def health():
+        info = settlement_info(settings)
+        return {
+            "status": "ok",
+            "service": "agentpay-gateway",
+            "payment_mode": settings.payment_mode,
+            "xhs_credentials": settings.has_xhs_credentials,
+            "mcp": "/mcp",
+            "settlement": info,
+        }
+
+    @app.get("/api/v1/pricing")
+    async def pricing_info():
+        """Public endpoint: returns payment requirements without serving data."""
+        return {
+            "services": [
+                {
+                    "name": "xhs_note_detail",
+                    "paid_endpoint": "/api/v1/paid/xhs/note",
+                    "amount": settings.payment_amount,
+                },
+                {
+                    "name": "xhs_user_notes",
+                    "paid_endpoint": "/api/v1/paid/xhs/user_notes",
+                    "amount": settings.payment_amount,
+                },
+                {
+                    "name": "china_wholesale_pricing",
+                    "paid_endpoint": "/api/v1/paid/sourcing",
+                    "amount": settings.payment_amount,
+                },
+            ],
+            "payment_required": True,
+            "network": settings.payment_network,
+            "token": settings.payment_token_symbol,
+            "recipient": settings.wallet_recipient_address,
+            "settlement": settlement_info(settings),
+        }
+
+    @app.get("/api/v1/paid/sourcing")
+    async def get_sourcing_data(
+        keyword: str = Query(..., description="Product search query"),
+        category_id: str | None = Query(None, description="Optional category filter"),
+        max_price: float | None = Query(None, description="Max unit price USD"),
+    ):
+        """Monetized endpoint: wholesale pricing data (requires x402 payment)."""
+        return query_wholesale_pricing(keyword, category_id, max_price)
+
+    @app.get("/api/v1/paid/xhs/note")
+    async def get_xhs_note(
+        note: str = Query(..., description="Xiaohongshu note URL or 24-char note_id"),
+        note_type: str | None = Query(
+            None, description="Optional hint: image | video | 图文 | 视频"
+        ),
+    ):
+        """Monetized: fetch Xiaohongshu note detail."""
+        if not settings.has_xhs_credentials:
+            return {
+                "status": "error",
+                "error": "Note data provider not configured on gateway",
+            }
+        return await fetch_note_detail(
+            note_id_or_link=note,
+            note_type_hint=note_type,
+            settings=settings,
+        )
+
+    @app.get("/api/v1/paid/xhs/user_notes")
+    async def get_xhs_user_notes(
+        user_id: str = Query(..., description="Xiaohongshu user ID"),
+        cursor: str = Query("", description="Pagination cursor from previous response"),
+    ):
+        """Monetized: fetch a user's posted notes list."""
+        if not settings.has_xhs_credentials:
+            return {
+                "status": "error",
+                "error": "Note data provider not configured on gateway",
+            }
+        return await fetch_user_notes(user_id=user_id, cursor=cursor, settings=settings)
+
+    return app
+
+
+app = create_app()
+
+
+def main() -> None:
+    # Clear settings cache so .env edits apply on restart
+    get_settings.cache_clear()
+    settings = get_settings()
+    info = settlement_info(settings)
+    # Railway/Cloud inject PORT
+    import os
+
+    port = int(os.getenv("PORT") or settings.gateway_port)
+    host = os.getenv("HOST") or settings.gateway_host or "0.0.0.0"
+    logger.info(
+        "Starting AgentPay Gateway on %s:%s mode=%s network=%s pay_to=%s facilitator=%s",
+        host,
+        port,
+        settings.payment_mode,
+        settings.payment_network,
+        settings.wallet_recipient_address,
+        info["facilitator"],
+    )
+    uvicorn.run(
+        "agentpay.gateway.app:app",
+        host=host,
+        port=port,
+        reload=False,
+    )
+
+
+if __name__ == "__main__":
+    main()

agentpay/gateway/data.py

@@ -0,0 +1,65 @@
+"""Mock wholesale pricing data provider."""
+
+from __future__ import annotations
+
+import hashlib
+from typing import Any
+
+
+def _stable_price(keyword: str, index: int) -> float:
+    seed = hashlib.md5(f"{keyword}:{index}".encode()).hexdigest()
+    return round(0.5 + (int(seed[:8], 16) % 500) / 100, 2)
+
+
+def _factory_locations() -> list[str]:
+    return [
+        "Yiwu, Zhejiang",
+        "Shenzhen, Guangdong",
+        "Guangzhou, Guangdong",
+        "Dongguan, Guangdong",
+        "Ningbo, Zhejiang",
+        "Hangzhou, Zhejiang",
+    ]
+
+
+def query_wholesale_pricing(
+    keyword: str,
+    category_id: str | None = None,
+    max_price: float | None = None,
+) -> dict[str, Any]:
+    """
+    Return structured manufacturing/wholesale data.
+    In production, this would call 1688/Yiwu APIs behind the paywall.
+    """
+    locations = _factory_locations()
+    items: list[dict[str, Any]] = []
+
+    for i in range(5):
+        unit_price = _stable_price(keyword, i)
+        if max_price is not None and unit_price > max_price:
+            continue
+
+        item_id = f"CN-{hashlib.md5(f'{keyword}{i}'.encode()).hexdigest()[:6].upper()}"
+        items.append(
+            {
+                "item_id": item_id,
+                "name": f"Factory Direct: {keyword.title()} — Model {i + 1}",
+                "factory_location": locations[i % len(locations)],
+                "supplier_verified": i % 2 == 0,
+                "moq": [100, 200, 500, 1000][i % 4],
+                "unit_price_usd": unit_price,
+                "lead_time_days": [5, 7, 10, 14][i % 4],
+                "platform": ["1688", "Yiwu Market", "Alibaba"][i % 3],
+            }
+        )
+
+    return {
+        "status": "success",
+        "data": {
+            "query": keyword,
+            "category_id": category_id,
+            "currency": "USD",
+            "total_results": len(items),
+            "items": items,
+        },
+    }

agentpay/gateway/middleware.py

@@ -0,0 +1,53 @@
+"""FastAPI x402 payment enforcement middleware."""
+
+from __future__ import annotations
+
+import logging
+
+from fastapi import Request
+from fastapi.responses import JSONResponse
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.responses import Response
+
+from agentpay.config import Settings, get_settings
+from agentpay.payment.verifier import build_402_body, build_402_headers, verify_payment
+
+logger = logging.getLogger(__name__)
+
+PROTECTED_PREFIX = "/api/v1/paid/"
+
+
+class X402PaymentMiddleware(BaseHTTPMiddleware):
+    """Intercept unpaid requests to monetized routes and return HTTP 402."""
+
+    def __init__(self, app, settings: Settings | None = None):
+        super().__init__(app)
+        self.settings = settings or get_settings()
+
+    async def dispatch(self, request: Request, call_next) -> Response:
+        if not request.url.path.startswith(PROTECTED_PREFIX):
+            return await call_next(request)
+
+        signature = request.headers.get("X-Payment-Signature")
+        payer = request.headers.get("X-Payment-Payer")
+
+        if not verify_payment(signature, payer, self.settings):
+            logger.info(
+                "402 challenge for %s %s (payer=%s)",
+                request.method,
+                request.url.path,
+                payer or "none",
+            )
+            return JSONResponse(
+                status_code=402,
+                headers=build_402_headers(self.settings),
+                content=build_402_body(self.settings),
+            )
+
+        response = await call_next(request)
+
+        # Attach settlement confirmation header
+        response.headers["X-Payment-Verified"] = "true"
+        if payer:
+            response.headers["X-Payment-Payer"] = payer
+        return response