lordevo-x402 0.1.0__tar.gz

lordevo_x402-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+node_modules/
+__pycache__/
+*.egg-info/
+dist/
+build/
+.venv/
+.pytest_cache/
+.npmrc
+.pypirc

lordevo_x402-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lordevo
+
+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.

lordevo_x402-0.1.0/PKG-INFO

@@ -0,0 +1,131 @@
+Metadata-Version: 2.5
+Name: lordevo-x402
+Version: 0.1.0
+Summary: Client for Lordevo's pay-per-call web, DNS, email and domain checks for AI agents: 33 tools from $0.01, paid with x402 (USDC on Base). LangChain and CrewAI tools included.
+Project-URL: Homepage, https://shop.lordevo.com
+Project-URL: Source, https://github.com/forbot26/lordevo-x402
+Project-URL: Issues, https://github.com/forbot26/lordevo-x402/issues
+Project-URL: Documentation, https://shop.lordevo.com/llms.txt
+Author-email: Lordevo <hello@lordevo.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: a2a,ai-agents,base,crewai,dns,langchain,mcp,robots.txt,security,seo,usdc,x402
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.80; extra == 'crewai'
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.3; extra == 'langchain'
+Provides-Extra: pay
+Requires-Dist: eth-account>=0.13; extra == 'pay'
+Requires-Dist: x402[evm,httpx,requests]>=2.25; extra == 'pay'
+Description-Content-Type: text/markdown
+
+# lordevo-x402 (Python)
+
+Python client for the pay-per-call checks at **[shop.lordevo.com](https://shop.lordevo.com)**. It has 33 web, DNS, email and domain tools for AI agents, priced from $0.01 per call and paid with [x402](https://x402.org) (USDC on Base). There's no account or API key: each call is one micro-payment from the agent's wallet. Calls that fail or get refused (4xx/5xx) are never charged. LangChain and CrewAI tools are included.
+
+```bash
+pip install lordevo-x402            # free helpers
+pip install "lordevo-x402[pay]"     # paid calls (x402 + eth-account)
+pip install "lordevo-x402[pay,langchain]"   # or [pay,crewai]
+```
+
+## Quickstart
+
+Free calls need no wallet:
+
+```python
+from lordevo_x402 import ask, quote, catalog
+
+ask("dns-lookup example.com")            # A2A router: the endpoint, price and payment terms
+quote("can-fetch", "https://example.com/blog")   # live x402 terms from the HTTP 402, nothing is paid
+len(catalog()["quick_checks"])           # 33
+```
+
+Paid calls need a Base wallet holding a little USDC:
+
+```python
+import os
+from lordevo_x402 import LordevoSync, Lordevo
+
+lo = LordevoSync.from_private_key(os.environ["AGENT_WALLET_KEY"], max_price_usd=0.02)
+lo.can_fetch("https://example.com/blog/post")    # robots.txt + AI-crawler gate, $0.01
+lo.dns_lookup("example.com", type="MX")          # $0.01
+lo.email_validate("jane@gmial.com")              # syntax + MX + disposable + typo hint, no SMTP, $0.01
+
+# async
+async with Lordevo.from_private_key(os.environ["AGENT_WALLET_KEY"]) as alo:
+    await alo.link_check("https://bit.ly/xyz")
+```
+
+- `max_price_usd` (default 0.05): tools priced above it are refused before any request.
+- `cache_seconds`: identical calls within the window are answered locally and not paid again.
+- Errors raise `LordevoError` with `status`, `code` and `charged`.
+- You can also pass your own paying client: `Lordevo(x402HttpxClient(...))` or `LordevoSync(x402_requests(...))`.
+
+## LangChain and CrewAI
+
+```python
+from lordevo_x402.langchain import langchain_tools
+tools = langchain_tools(sync_client=lo, only=["can-fetch", "link-check", "dns-lookup"])
+
+from lordevo_x402.crewai import crewai_tools
+agent = Agent(role="Researcher", goal="...", backstory="...", tools=crewai_tools(lo, only=["can-fetch", "link-check"]))
+```
+
+## Tools
+
+These are the live prices from [catalog.json](https://shop.lordevo.com/catalog.json). Call any of them with `lo.call(slug, value, **options)` or as a method (`lo.dns_lookup`).
+
+| Tool | Input | Price | What it does |
+|---|---|---|---|
+| `site-check` | `url` | $0.03 | Site check: trust + AI readiness + security headers (recommended start) |
+| `agent-readiness` | `url` | $0.03 | Agent readiness / AI visibility score (GEO) |
+| `url-trust` | `url` | $0.01 | URL trust check before you click or pay (safe / caution / risky) |
+| `can-fetch` | `url` | $0.01 | Can I fetch this URL? robots.txt + AI-crawler permission gate |
+| `link-check` | `url` | $0.01 | Link check: is it alive, where does it really go (redirects resolved) |
+| `dns-lookup` | `host` (+ type) | $0.01 | DNS lookup (A, AAAA, CNAME, MX, TXT, NS, SOA, CAA) |
+| `email-validate` | `email` | $0.01 | Email address validation (syntax + domain + MX, no SMTP probing) |
+| `ssl-cert` | `host` | $0.01 | SSL/TLS certificate check (expiry, issuer, SANs, chain) |
+| `domain-rdap` | `domain` | $0.01 | Domain age, registrar and expiry (RDAP) |
+| `ip-info` | `ip` | $0.01 | IP address owner and network (RDAP + reverse DNS) |
+| `links-batch` | `urls` | $0.02 | Batch link check (up to 10 URLs per call) |
+| `broken-links` | `url` | $0.02 | Broken links on a page (up to 40 links checked) |
+| `sitemap-urls` | `url` | $0.01 | Sitemap URL extractor (robots.txt + sitemap index) |
+| `link-preview` | `url` | $0.01 | Link preview / unfurl (title, description, image, favicon, logo) |
+| `readability` | `url` | $0.01 | Readability and word count (Flesch, reading time, top terms) |
+| `structured-data` | `url` | $0.01 | Structured data extractor (JSON-LD, microdata, RDFa) |
+| `canonical-check` | `url` | $0.01 | Canonical, hreflang and indexability check |
+| `cors-check` | `url` (+ origin, method) | $0.01 | CORS check (preflight + allowed origins) |
+| `http-ping` | `url` | $0.01 | HTTP ping: up or down, status and timings (DNS, TCP, TLS, TTFB) |
+| `domain-lookalike` | `host` | $0.01 | Lookalike / homograph domain check (punycode, mixed scripts, brand typos) |
+| `myr-rates` | `currency` | $0.01 | Malaysian ringgit exchange rates + OPR (Bank Negara Malaysia data) |
+| `verdict-card` | `url` | $0.02 | Shareable site verdict card (grade + one-liner, SVG) |
+| `page-markdown` | `url` | $0.01 | Page to Markdown (main content) |
+| `page-meta` | `url` | $0.01 | Page metadata + Markdown |
+| `email-auth` | `domain` | $0.01 | Email authentication check (SPF, DKIM, DMARC) |
+| `security-headers` | `url` | $0.01 | Security headers + TLS quick grade |
+| `tech-stack` | `url` | $0.02 | Tech stack detection |
+| `seo-page` | `url` | $0.02 | On-page SEO check (one page) |
+| `site-snapshot` | `url` | $0.03 | Site snapshot (SEO + security + tech + email) |
+| `page-quality` | `url` | $0.01 | Page quality verdict (AI) |
+| `site-verdict` | `url` | $0.02 | Is this a legit business site? (AI trust verdict) |
+| `seo-audit-lite` | `url` | $0.03 | SEO Audit LITE (top 10 issues, one page) |
+| `security-scan-lite` | `url` | $0.03 | Website Security Scan LITE (passive summary) |
+## Other ways in
+
+| Interface | Endpoint |
+|---|---|
+| MCP (streamable HTTP, x402 MCP transport) | `https://shop.lordevo.com/mcp` |
+| A2A JSON-RPC (`message/send`, a free router) | `https://shop.lordevo.com/a2a` |
+| x402 manifest | `https://shop.lordevo.com/.well-known/x402.json` |
+| OpenAPI 3.1 | `https://shop.lordevo.com/openapi.json` |
+
+Only check sites you are allowed to check. All checks are passive and read-only.
+
+JavaScript package: [`lordevo-x402` on npm](https://www.npmjs.com/package/lordevo-x402). Source: [github.com/forbot26/lordevo-x402](https://github.com/forbot26/lordevo-x402). MIT licence.

lordevo_x402-0.1.0/README.md

@@ -0,0 +1,104 @@
+# lordevo-x402 (Python)
+
+Python client for the pay-per-call checks at **[shop.lordevo.com](https://shop.lordevo.com)**. It has 33 web, DNS, email and domain tools for AI agents, priced from $0.01 per call and paid with [x402](https://x402.org) (USDC on Base). There's no account or API key: each call is one micro-payment from the agent's wallet. Calls that fail or get refused (4xx/5xx) are never charged. LangChain and CrewAI tools are included.
+
+```bash
+pip install lordevo-x402            # free helpers
+pip install "lordevo-x402[pay]"     # paid calls (x402 + eth-account)
+pip install "lordevo-x402[pay,langchain]"   # or [pay,crewai]
+```
+
+## Quickstart
+
+Free calls need no wallet:
+
+```python
+from lordevo_x402 import ask, quote, catalog
+
+ask("dns-lookup example.com")            # A2A router: the endpoint, price and payment terms
+quote("can-fetch", "https://example.com/blog")   # live x402 terms from the HTTP 402, nothing is paid
+len(catalog()["quick_checks"])           # 33
+```
+
+Paid calls need a Base wallet holding a little USDC:
+
+```python
+import os
+from lordevo_x402 import LordevoSync, Lordevo
+
+lo = LordevoSync.from_private_key(os.environ["AGENT_WALLET_KEY"], max_price_usd=0.02)
+lo.can_fetch("https://example.com/blog/post")    # robots.txt + AI-crawler gate, $0.01
+lo.dns_lookup("example.com", type="MX")          # $0.01
+lo.email_validate("jane@gmial.com")              # syntax + MX + disposable + typo hint, no SMTP, $0.01
+
+# async
+async with Lordevo.from_private_key(os.environ["AGENT_WALLET_KEY"]) as alo:
+    await alo.link_check("https://bit.ly/xyz")
+```
+
+- `max_price_usd` (default 0.05): tools priced above it are refused before any request.
+- `cache_seconds`: identical calls within the window are answered locally and not paid again.
+- Errors raise `LordevoError` with `status`, `code` and `charged`.
+- You can also pass your own paying client: `Lordevo(x402HttpxClient(...))` or `LordevoSync(x402_requests(...))`.
+
+## LangChain and CrewAI
+
+```python
+from lordevo_x402.langchain import langchain_tools
+tools = langchain_tools(sync_client=lo, only=["can-fetch", "link-check", "dns-lookup"])
+
+from lordevo_x402.crewai import crewai_tools
+agent = Agent(role="Researcher", goal="...", backstory="...", tools=crewai_tools(lo, only=["can-fetch", "link-check"]))
+```
+
+## Tools
+
+These are the live prices from [catalog.json](https://shop.lordevo.com/catalog.json). Call any of them with `lo.call(slug, value, **options)` or as a method (`lo.dns_lookup`).
+
+| Tool | Input | Price | What it does |
+|---|---|---|---|
+| `site-check` | `url` | $0.03 | Site check: trust + AI readiness + security headers (recommended start) |
+| `agent-readiness` | `url` | $0.03 | Agent readiness / AI visibility score (GEO) |
+| `url-trust` | `url` | $0.01 | URL trust check before you click or pay (safe / caution / risky) |
+| `can-fetch` | `url` | $0.01 | Can I fetch this URL? robots.txt + AI-crawler permission gate |
+| `link-check` | `url` | $0.01 | Link check: is it alive, where does it really go (redirects resolved) |
+| `dns-lookup` | `host` (+ type) | $0.01 | DNS lookup (A, AAAA, CNAME, MX, TXT, NS, SOA, CAA) |
+| `email-validate` | `email` | $0.01 | Email address validation (syntax + domain + MX, no SMTP probing) |
+| `ssl-cert` | `host` | $0.01 | SSL/TLS certificate check (expiry, issuer, SANs, chain) |
+| `domain-rdap` | `domain` | $0.01 | Domain age, registrar and expiry (RDAP) |
+| `ip-info` | `ip` | $0.01 | IP address owner and network (RDAP + reverse DNS) |
+| `links-batch` | `urls` | $0.02 | Batch link check (up to 10 URLs per call) |
+| `broken-links` | `url` | $0.02 | Broken links on a page (up to 40 links checked) |
+| `sitemap-urls` | `url` | $0.01 | Sitemap URL extractor (robots.txt + sitemap index) |
+| `link-preview` | `url` | $0.01 | Link preview / unfurl (title, description, image, favicon, logo) |
+| `readability` | `url` | $0.01 | Readability and word count (Flesch, reading time, top terms) |
+| `structured-data` | `url` | $0.01 | Structured data extractor (JSON-LD, microdata, RDFa) |
+| `canonical-check` | `url` | $0.01 | Canonical, hreflang and indexability check |
+| `cors-check` | `url` (+ origin, method) | $0.01 | CORS check (preflight + allowed origins) |
+| `http-ping` | `url` | $0.01 | HTTP ping: up or down, status and timings (DNS, TCP, TLS, TTFB) |
+| `domain-lookalike` | `host` | $0.01 | Lookalike / homograph domain check (punycode, mixed scripts, brand typos) |
+| `myr-rates` | `currency` | $0.01 | Malaysian ringgit exchange rates + OPR (Bank Negara Malaysia data) |
+| `verdict-card` | `url` | $0.02 | Shareable site verdict card (grade + one-liner, SVG) |
+| `page-markdown` | `url` | $0.01 | Page to Markdown (main content) |
+| `page-meta` | `url` | $0.01 | Page metadata + Markdown |
+| `email-auth` | `domain` | $0.01 | Email authentication check (SPF, DKIM, DMARC) |
+| `security-headers` | `url` | $0.01 | Security headers + TLS quick grade |
+| `tech-stack` | `url` | $0.02 | Tech stack detection |
+| `seo-page` | `url` | $0.02 | On-page SEO check (one page) |
+| `site-snapshot` | `url` | $0.03 | Site snapshot (SEO + security + tech + email) |
+| `page-quality` | `url` | $0.01 | Page quality verdict (AI) |
+| `site-verdict` | `url` | $0.02 | Is this a legit business site? (AI trust verdict) |
+| `seo-audit-lite` | `url` | $0.03 | SEO Audit LITE (top 10 issues, one page) |
+| `security-scan-lite` | `url` | $0.03 | Website Security Scan LITE (passive summary) |
+## Other ways in
+
+| Interface | Endpoint |
+|---|---|
+| MCP (streamable HTTP, x402 MCP transport) | `https://shop.lordevo.com/mcp` |
+| A2A JSON-RPC (`message/send`, a free router) | `https://shop.lordevo.com/a2a` |
+| x402 manifest | `https://shop.lordevo.com/.well-known/x402.json` |
+| OpenAPI 3.1 | `https://shop.lordevo.com/openapi.json` |
+
+Only check sites you are allowed to check. All checks are passive and read-only.
+
+JavaScript package: [`lordevo-x402` on npm](https://www.npmjs.com/package/lordevo-x402). Source: [github.com/forbot26/lordevo-x402](https://github.com/forbot26/lordevo-x402). MIT licence.

lordevo_x402-0.1.0/lordevo_x402/__init__.py

@@ -0,0 +1,203 @@
+"""lordevo-x402: client for the pay-per-call checks at https://shop.lordevo.com (x402, USDC on Base).
+
+Free (no wallet):   catalog(), quote(slug, value), ask(text)
+Paid, async:        async with Lordevo.from_private_key(key) as lo: await lo.dns_lookup("example.com", type="MX")
+Paid, sync:         lo = LordevoSync.from_private_key(key); lo.can_fetch("https://example.com/page")
+"""
+from __future__ import annotations
+
+import base64
+import json
+import time
+import uuid
+from importlib import resources
+from typing import Any
+from urllib.parse import urlencode
+
+import httpx
+
+__version__ = "0.1.0"
+__all__ = ["BASE_URL", "TOOLS", "Lordevo", "LordevoSync", "LordevoError", "tool_url", "catalog", "quote", "ask"]
+
+BASE_URL = "https://shop.lordevo.com"
+TOOLS: dict[str, dict] = {t["slug"]: t for t in json.loads(resources.files(__package__).joinpath("tools.json").read_text())["tools"]}
+
+
+class LordevoError(Exception):
+    def __init__(self, status: int, body: Any):
+        msg = body.get("message") if isinstance(body, dict) and body.get("message") else f"HTTP {status}"
+        super().__init__(msg)
+        self.status, self.body = status, body
+        self.code = body.get("error") if isinstance(body, dict) else None
+        self.charged = body.get("charged") if isinstance(body, dict) else None
+
+
+def _query(slug: str, value: str | None, params: dict) -> dict:
+    t = TOOLS.get(slug)
+    if not t:
+        raise ValueError(f"Unknown Lordevo tool: {slug}")
+    if value is not None:
+        params = {**params, t["param"]: value}
+    if not params.get(t["param"]):
+        raise ValueError(f'{slug} needs "{t["param"]}" ({t.get("param_description", "")})')
+    return {t["param"]: str(params[t["param"]]), **{k: str(v) for k, v in params.items() if k in (t.get("options") or {}) and v is not None}}
+
+
+def tool_url(slug: str, value: str | None = None, base_url: str = BASE_URL, **params: Any) -> str:
+    """Endpoint URL for one call (raises before any request on unknown tool or missing input)."""
+    return f"{base_url}/api/quick/{slug}?{urlencode(_query(slug, value, params))}"
+
+
+# ---------- free helpers (no wallet) ----------
+def catalog(base_url: str = BASE_URL, client: httpx.Client | None = None) -> dict:
+    c = client or httpx.Client(timeout=30)
+    try:
+        r = c.get(f"{base_url}/catalog.json", headers={"accept": "application/json"})
+        if r.status_code >= 400:
+            raise LordevoError(r.status_code, None)
+        return r.json()
+    finally:
+        if client is None:
+            c.close()
+
+
+def quote(slug: str, value: str | None = None, base_url: str = BASE_URL, client: httpx.Client | None = None, **params: Any) -> dict:
+    """Live x402 terms for one call, read from the HTTP 402. Nothing is paid."""
+    url = tool_url(slug, value, base_url, **params)
+    c = client or httpx.Client(timeout=30)
+    try:
+        r = c.get(url, headers={"accept": "application/json"})
+    finally:
+        if client is None:
+            c.close()
+    try:
+        body = r.json()
+    except ValueError:
+        body = None
+    if r.status_code != 402:
+        raise LordevoError(r.status_code, body)
+    h = r.headers.get("payment-required")
+    pr = json.loads(base64.b64decode(h)) if h else body
+    a = (pr or {}).get("accepts", [{}])[0]
+    amount = str(a.get("amount") or a.get("maxAmountRequired"))
+    return {"tool": slug, "url": url, "price_usd": int(amount) / 1e6, "amount": amount, "asset": a.get("asset"), "network": a.get("network"), "payTo": a.get("payTo"), "scheme": a.get("scheme"), "x402": pr}
+
+
+def ask(text: str, base_url: str = BASE_URL, client: httpx.Client | None = None) -> dict:
+    """Ask the shop's free A2A router which check fits (e.g. "dns-lookup example.com")."""
+    msg = {"kind": "message", "role": "user", "messageId": str(uuid.uuid4()), "parts": [{"kind": "text", "text": str(text)}]}
+    c = client or httpx.Client(timeout=30)
+    try:
+        r = c.post(f"{base_url}/a2a", json={"jsonrpc": "2.0", "id": 1, "method": "message/send", "params": {"message": msg}})
+    finally:
+        if client is None:
+            c.close()
+    j = r.json()
+    if r.status_code >= 400 or "error" in j:
+        raise LordevoError(r.status_code, j.get("error"))
+    parts = j["result"]["parts"]
+    out = {"text": next((p["text"] for p in parts if p.get("kind") == "text"), "")}
+    out.update(next((p["data"] for p in parts if p.get("kind") == "data"), {}))
+    return out
+
+
+# ---------- paid clients ----------
+class _Base:
+    def __init__(self, client: Any, base_url: str = BASE_URL, max_price_usd: float = 0.05, cache_seconds: float = 0):
+        self.client, self.base_url, self.max_price_usd, self.cache_seconds = client, base_url, max_price_usd, cache_seconds
+        self._memo: dict[str, tuple[float, Any]] = {}
+        self.tools = TOOLS
+
+    def _prep(self, slug: str, value: str | None, params: dict) -> tuple[str, dict, str]:
+        t = TOOLS.get(slug)
+        if not t:
+            raise ValueError(f"Unknown Lordevo tool: {slug}")
+        if t["price_usd"] > self.max_price_usd:
+            raise ValueError(f"{slug} costs ${t['price_usd']}, above max_price_usd ${self.max_price_usd}")
+        q = _query(slug, value, params)
+        return f"{self.base_url}/api/quick/{slug}", q, f"{slug}?{sorted(q.items())}"
+
+    def _cached(self, key: str):
+        if self.cache_seconds and key in self._memo and time.time() - self._memo[key][0] < self.cache_seconds:
+            return True, self._memo[key][1]
+        return False, None
+
+    def _done(self, key: str, status: int, body: Any):
+        if status >= 400:
+            raise LordevoError(status, body)
+        if self.cache_seconds:
+            self._memo[key] = (time.time(), body)
+            if len(self._memo) > 1000:
+                self._memo.pop(next(iter(self._memo)))
+        return body
+
+    def __getattr__(self, name: str):
+        slug = name.replace("_", "-")
+        if slug in TOOLS:
+            return lambda value=None, **p: self.call(slug, value, **p)
+        raise AttributeError(name)
+
+
+def _json(r):
+    try:
+        return r.json()
+    except ValueError:
+        return None
+
+
+class Lordevo(_Base):
+    """Async client. Pass any httpx.AsyncClient that pays x402 (e.g. x402.http.clients.x402HttpxClient)."""
+
+    @classmethod
+    def from_private_key(cls, private_key: str, **kw) -> "Lordevo":
+        from eth_account import Account
+        from x402 import x402Client
+        from x402.http.clients import x402HttpxClient
+        from x402.mechanisms.evm.exact import register_exact_evm_client
+
+        x = x402Client()
+        register_exact_evm_client(x, Account.from_key(private_key), networks="eip155:8453")
+        return cls(x402HttpxClient(x, timeout=60), **kw)
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *exc):
+        await self.client.aclose()
+
+    async def call(self, slug: str, value: str | None = None, **params: Any) -> dict:
+        url, q, key = self._prep(slug, value, params)
+        hit, out = self._cached(key)
+        if hit:
+            return out
+        r = await self.client.get(url, params=q, headers={"accept": "application/json"})
+        return self._done(key, r.status_code, _json(r))
+
+
+class LordevoSync(_Base):
+    """Sync client. Pass a paying requests.Session (x402.http.clients.x402_requests) or httpx.Client."""
+
+    @classmethod
+    def from_private_key(cls, private_key: str, **kw) -> "LordevoSync":
+        from eth_account import Account
+        from x402 import x402ClientSync
+        from x402.http.clients import x402_requests
+        from x402.mechanisms.evm.exact import register_exact_evm_client
+
+        x = x402ClientSync()
+        register_exact_evm_client(x, Account.from_key(private_key), networks="eip155:8453")
+        return cls(x402_requests(x), **kw)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        self.client.close()
+
+    def call(self, slug: str, value: str | None = None, **params: Any) -> dict:
+        url, q, key = self._prep(slug, value, params)
+        hit, out = self._cached(key)
+        if hit:
+            return out
+        r = self.client.get(url, params=q, headers={"accept": "application/json"})
+        return self._done(key, r.status_code, _json(r))

lordevo_x402-0.1.0/lordevo_x402/crewai.py

@@ -0,0 +1,30 @@
+"""CrewAI tools, one per Lordevo check:  Agent(..., tools=crewai_tools(LordevoSync.from_private_key(key), only=[...]))"""
+
+import json
+from typing import Any, Optional
+
+from . import TOOLS
+
+
+def crewai_tools(client: Any, only: Optional[list] = None):
+    """client: a LordevoSync (CrewAI tools run synchronously)."""
+    from crewai.tools import BaseTool
+    from pydantic import BaseModel, Field, create_model
+
+    def make(slug: str, t: dict):
+        fields = {t["param"]: (str, Field(..., description=t.get("param_description", t["param"])))}
+        for k, o in (t.get("options") or {}).items():
+            fields[k] = (Optional[str], Field(None, description=o.get("description", k)))
+        Args = create_model(f"{t['mcp_tool']}_args", **fields)
+
+        class LordevoTool(BaseTool):
+            name: str = t["mcp_tool"]
+            description: str = f"{t['title']}. Costs ${t['price_usd']:.2f} per call (x402, USDC on Base)."
+            args_schema: type[BaseModel] = Args
+
+            def _run(self, **kw) -> str:
+                return json.dumps(client.call(slug, **{k: v for k, v in kw.items() if v is not None}))
+
+        return LordevoTool()
+
+    return [make(s, t) for s, t in TOOLS.items() if not only or s in only]

lordevo_x402-0.1.0/lordevo_x402/langchain.py

@@ -0,0 +1,38 @@
+"""LangChain tools, one per Lordevo check:  tools = langchain_tools(sync_client=LordevoSync..., async_client=Lordevo..., only=[...])"""
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from . import TOOLS
+
+
+def _schema(t: dict) -> dict:
+    props = {t["param"]: {"type": "string", "description": t.get("param_description", t["param"])}}
+    for k, o in (t.get("options") or {}).items():
+        props[k] = {"type": "string", "description": o.get("description", k), **({"enum": o["enum"]} if "enum" in o else {})}
+    return {"type": "object", "properties": props, "required": [t["param"]]}
+
+
+def langchain_tools(sync_client: Any = None, async_client: Any = None, only: list[str] | None = None):
+    """sync_client: a LordevoSync; async_client: a Lordevo. Give at least one."""
+    from langchain_core.tools import StructuredTool
+
+    if sync_client is None and async_client is None:
+        raise ValueError("give sync_client (LordevoSync) and/or async_client (Lordevo)")
+
+    def make(slug: str, t: dict):
+        def run(**kw):
+            if sync_client is None:
+                raise RuntimeError("this tool was built with an async client only; use ainvoke")
+            return json.dumps(sync_client.call(slug, **kw))
+
+        async def arun(**kw):
+            if async_client is None:
+                return run(**kw)
+            return json.dumps(await async_client.call(slug, **kw))
+
+        return StructuredTool.from_function(func=run, coroutine=arun, name=t["mcp_tool"], args_schema=_schema(t),
+                                            description=f"{t['title']}. Costs ${t['price_usd']:.2f} per call (x402, USDC on Base); failed calls are not charged.")
+
+    return [make(s, t) for s, t in TOOLS.items() if not only or s in only]

lordevo_x402-0.1.0/lordevo_x402/tools.json

@@ -0,0 +1,402 @@
+{
+ "source": "https://shop.lordevo.com/catalog.json",
+ "generated": "2026-10-27",
+ "tools": [
+  {
+   "slug": "site-check",
+   "mcp_tool": "site_check",
+   "param": "url",
+   "param_description": "Public http(s) URL or bare domain, e.g. https://example.com",
+   "options": {},
+   "price_usd": 0.03,
+   "title": "Site check: trust + AI readiness + security headers (recommended start)",
+   "ai": false,
+   "category": "website"
+  },
+  {
+   "slug": "agent-readiness",
+   "mcp_tool": "agent_readiness",
+   "param": "url",
+   "param_description": "Public http(s) URL or bare domain, e.g. https://example.com",
+   "options": {},
+   "price_usd": 0.03,
+   "title": "Agent readiness / AI visibility score (GEO)",
+   "ai": false,
+   "category": "seo"
+  },
+  {
+   "slug": "url-trust",
+   "mcp_tool": "url_trust",
+   "param": "url",
+   "param_description": "Public http(s) URL or bare domain, e.g. https://example.com",
+   "options": {},
+   "price_usd": 0.01,
+   "title": "URL trust check before you click or pay (safe / caution / risky)",
+   "ai": false,
+   "category": "security"
+  },
+  {
+   "slug": "can-fetch",
+   "mcp_tool": "can_fetch",
+   "param": "url",
+   "param_description": "Public http(s) URL or bare domain, e.g. https://example.com",
+   "options": {},
+   "price_usd": 0.01,
+   "title": "Can I fetch this URL? robots.txt + AI-crawler permission gate",
+   "ai": false,
+   "category": "web-scraping"
+  },
+  {
+   "slug": "link-check",
+   "mcp_tool": "link_check",
+   "param": "url",
+   "param_description": "Public http(s) URL or bare domain, e.g. https://example.com",
+   "options": {},
+   "price_usd": 0.01,
+   "title": "Link check: is it alive, where does it really go (redirects resolved)",
+   "ai": false,
+   "category": "web"
+  },
+  {
+   "slug": "dns-lookup",
+   "mcp_tool": "dns_lookup",
+   "param": "host",
+   "param_description": "Public host name, e.g. example.com or www.example.com (a URL also works)",
+   "options": {
+    "type": {
+     "enum": [
+      "ALL",
+      "A",
+      "AAAA",
+      "CNAME",
+      "MX",
+      "TXT",
+      "NS",
+      "SOA",
+      "CAA"
+     ],
+     "default": "ALL",
+     "description": "Record type (default ALL = A, AAAA, CNAME, MX, TXT, NS, SOA, CAA)"
+    }
+   },
+   "price_usd": 0.01,
+   "title": "DNS lookup (A, AAAA, CNAME, MX, TXT, NS, SOA, CAA)",
+   "ai": false,
+   "category": "dns"
+  },
+  {
+   "slug": "email-validate",
+   "mcp_tool": "email_validate",
+   "param": "email",
+   "param_description": "Email address, e.g. jane@example.com",
+   "options": {},
+   "price_usd": 0.01,
+   "title": "Email address validation (syntax + domain + MX, no SMTP probing)",
+   "ai": false,
+   "category": "email"
+  },
+  {
+   "slug": "ssl-cert",
+   "mcp_tool": "ssl_cert",
+   "param": "host",
+   "param_description": "Public host name, e.g. example.com or www.example.com (a URL also works)",
+   "options": {},
+   "price_usd": 0.01,
+   "title": "SSL/TLS certificate check (expiry, issuer, SANs, chain)",
+   "ai": false,
+   "category": "security"
+  },
+  {
+   "slug": "domain-rdap",
+   "mcp_tool": "domain_rdap",
+   "param": "domain",
+   "param_description": "Domain name, e.g. example.com (a URL or email address also works)",
+   "options": {},
+   "price_usd": 0.01,
+   "title": "Domain age, registrar and expiry (RDAP)",
+   "ai": false,
+   "category": "domain"
+  },
+  {
+   "slug": "ip-info",
+   "mcp_tool": "ip_info",
+   "param": "ip",
+   "param_description": "Public IPv4 or IPv6 address, e.g. 8.8.8.8",
+   "options": {},
+   "price_usd": 0.01,
+   "title": "IP address owner and network (RDAP + reverse DNS)",
+   "ai": false,
+   "category": "network"
+  },
+  {
+   "slug": "links-batch",
+   "mcp_tool": "links_batch",
+   "param": "urls",
+   "param_description": "1-10 public http(s) URLs, comma-separated",
+   "options": {},
+   "price_usd": 0.02,
+   "title": "Batch link check (up to 10 URLs per call)",
+   "ai": false,
+   "category": "web"
+  },
+  {
+   "slug": "broken-links",
+   "mcp_tool": "broken_links",
+   "param": "url",
+   "param_description": "Public http(s) URL or bare domain, e.g. https://example.com",
+   "options": {},
+   "price_usd": 0.02,
+   "title": "Broken links on a page (up to 40 links checked)",
+   "ai": false,
+   "category": "seo"
+  },
+  {
+   "slug": "sitemap-urls",
+   "mcp_tool": "sitemap_urls",
+   "param": "url",
+   "param_description": "Public http(s) URL or bare domain, e.g. https://example.com",
+   "options": {},
+   "price_usd": 0.01,
+   "title": "Sitemap URL extractor (robots.txt + sitemap index)",
+   "ai": false,
+   "category": "web-scraping"
+  },
+  {
+   "slug": "link-preview",
+   "mcp_tool": "link_preview",
+   "param": "url",
+   "param_description": "Public http(s) URL or bare domain, e.g. https://example.com",
+   "options": {},
+   "price_usd": 0.01,
+   "title": "Link preview / unfurl (title, description, image, favicon, logo)",
+   "ai": false,
+   "category": "web-scraping"
+  },
+  {
+   "slug": "readability",
+   "mcp_tool": "readability",
+   "param": "url",
+   "param_description": "Public http(s) URL or bare domain, e.g. https://example.com",
+   "options": {},
+   "price_usd": 0.01,
+   "title": "Readability and word count (Flesch, reading time, top terms)",
+   "ai": false,
+   "category": "content"
+  },
+  {
+   "slug": "structured-data",
+   "mcp_tool": "structured_data",
+   "param": "url",
+   "param_description": "Public http(s) URL or bare domain, e.g. https://example.com",
+   "options": {},
+   "price_usd": 0.01,
+   "title": "Structured data extractor (JSON-LD, microdata, RDFa)",
+   "ai": false,
+   "category": "seo"
+  },
+  {
+   "slug": "canonical-check",
+   "mcp_tool": "canonical_check",
+   "param": "url",
+   "param_description": "Public http(s) URL or bare domain, e.g. https://example.com",
+   "options": {},
+   "price_usd": 0.01,
+   "title": "Canonical, hreflang and indexability check",
+   "ai": false,
+   "category": "seo"
+  },
+  {
+   "slug": "cors-check",
+   "mcp_tool": "cors_check",
+   "param": "url",
+   "param_description": "Public http(s) URL or bare domain, e.g. https://example.com",
+   "options": {
+    "origin": {
+     "pattern": "^https?://[a-zA-Z0-9.-]+(:\\d{1,5})?$",
+     "default": "https://example.com",
+     "description": "Origin to test, e.g. https://app.example.com"
+    },
+    "method": {
+     "enum": [
+      "GET",
+      "POST",
+      "PUT",
+      "PATCH",
+      "DELETE"
+     ],
+     "default": "GET",
+     "description": "Method for the preflight"
+    }
+   },
+   "price_usd": 0.01,
+   "title": "CORS check (preflight + allowed origins)",
+   "ai": false,
+   "category": "security"
+  },
+  {
+   "slug": "http-ping",
+   "mcp_tool": "http_ping",
+   "param": "url",
+   "param_description": "Public http(s) URL or bare domain, e.g. https://example.com",
+   "options": {},
+   "price_usd": 0.01,
+   "title": "HTTP ping: up or down, status and timings (DNS, TCP, TLS, TTFB)",
+   "ai": false,
+   "category": "monitoring"
+  },
+  {
+   "slug": "domain-lookalike",
+   "mcp_tool": "domain_lookalike",
+   "param": "host",
+   "param_description": "Public host name, e.g. example.com or www.example.com (a URL also works)",
+   "options": {},
+   "price_usd": 0.01,
+   "title": "Lookalike / homograph domain check (punycode, mixed scripts, brand typos)",
+   "ai": false,
+   "category": "security"
+  },
+  {
+   "slug": "myr-rates",
+   "mcp_tool": "myr_rates",
+   "param": "currency",
+   "param_description": "3-letter currency code (e.g. USD, SGD, EUR) or ALL",
+   "options": {},
+   "price_usd": 0.01,
+   "title": "Malaysian ringgit exchange rates + OPR (Bank Negara Malaysia data)",
+   "ai": false,
+   "category": "finance"
+  },
+  {
+   "slug": "verdict-card",
+   "mcp_tool": "verdict_card",
+   "param": "url",
+   "param_description": "Public http(s) URL or bare domain, e.g. https://example.com",
+   "options": {},
+   "price_usd": 0.02,
+   "title": "Shareable site verdict card (grade + one-liner, SVG)",
+   "ai": true,
+   "category": "ai"
+  },
+  {
+   "slug": "page-markdown",
+   "mcp_tool": "page_markdown",
+   "param": "url",
+   "param_description": "Public http(s) URL or bare domain, e.g. https://example.com",
+   "options": {},
+   "price_usd": 0.01,
+   "title": "Page to Markdown (main content)",
+   "ai": false,
+   "category": "web-scraping"
+  },
+  {
+   "slug": "page-meta",
+   "mcp_tool": "page_meta",
+   "param": "url",
+   "param_description": "Public http(s) URL or bare domain, e.g. https://example.com",
+   "options": {},
+   "price_usd": 0.01,
+   "title": "Page metadata + Markdown",
+   "ai": false,
+   "category": "web"
+  },
+  {
+   "slug": "email-auth",
+   "mcp_tool": "email_auth",
+   "param": "domain",
+   "param_description": "Domain name, e.g. example.com (a URL or email address also works)",
+   "options": {},
+   "price_usd": 0.01,
+   "title": "Email authentication check (SPF, DKIM, DMARC)",
+   "ai": false,
+   "category": "security"
+  },
+  {
+   "slug": "security-headers",
+   "mcp_tool": "security_headers",
+   "param": "url",
+   "param_description": "Public http(s) URL or bare domain, e.g. https://example.com",
+   "options": {},
+   "price_usd": 0.01,
+   "title": "Security headers + TLS quick grade",
+   "ai": false,
+   "category": "security"
+  },
+  {
+   "slug": "tech-stack",
+   "mcp_tool": "tech_stack",
+   "param": "url",
+   "param_description": "Public http(s) URL or bare domain, e.g. https://example.com",
+   "options": {},
+   "price_usd": 0.02,
+   "title": "Tech stack detection",
+   "ai": false,
+   "category": "web"
+  },
+  {
+   "slug": "seo-page",
+   "mcp_tool": "seo_page",
+   "param": "url",
+   "param_description": "Public http(s) URL or bare domain, e.g. https://example.com",
+   "options": {},
+   "price_usd": 0.02,
+   "title": "On-page SEO check (one page)",
+   "ai": false,
+   "category": "seo"
+  },
+  {
+   "slug": "site-snapshot",
+   "mcp_tool": "site_snapshot",
+   "param": "url",
+   "param_description": "Public http(s) URL or bare domain, e.g. https://example.com",
+   "options": {},
+   "price_usd": 0.03,
+   "title": "Site snapshot (SEO + security + tech + email)",
+   "ai": false,
+   "category": "web"
+  },
+  {
+   "slug": "page-quality",
+   "mcp_tool": "page_quality",
+   "param": "url",
+   "param_description": "Public http(s) URL or bare domain, e.g. https://example.com",
+   "options": {},
+   "price_usd": 0.01,
+   "title": "Page quality verdict (AI)",
+   "ai": true,
+   "category": "ai"
+  },
+  {
+   "slug": "site-verdict",
+   "mcp_tool": "site_verdict",
+   "param": "url",
+   "param_description": "Public http(s) URL or bare domain, e.g. https://example.com",
+   "options": {},
+   "price_usd": 0.02,
+   "title": "Is this a legit business site? (AI trust verdict)",
+   "ai": true,
+   "category": "ai"
+  },
+  {
+   "slug": "seo-audit-lite",
+   "mcp_tool": "seo_audit_lite",
+   "param": "url",
+   "param_description": "Public http(s) URL or bare domain, e.g. https://example.com",
+   "options": {},
+   "price_usd": 0.03,
+   "title": "SEO Audit LITE (top 10 issues, one page)",
+   "ai": false,
+   "category": "seo"
+  },
+  {
+   "slug": "security-scan-lite",
+   "mcp_tool": "security_scan_lite",
+   "param": "url",
+   "param_description": "Public http(s) URL or bare domain, e.g. https://example.com",
+   "options": {},
+   "price_usd": 0.03,
+   "title": "Website Security Scan LITE (passive summary)",
+   "ai": false,
+   "category": "security"
+  }
+ ]
+}

lordevo_x402-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[project]
+name = "lordevo-x402"
+version = "0.1.0"
+description = "Client for Lordevo's pay-per-call web, DNS, email and domain checks for AI agents: 33 tools from $0.01, paid with x402 (USDC on Base). LangChain and CrewAI tools included."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Lordevo", email = "hello@lordevo.com" }]
+keywords = ["x402", "ai-agents", "mcp", "a2a", "langchain", "crewai", "seo", "security", "dns", "robots.txt", "usdc", "base"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+  "Intended Audience :: Developers",
+  "Topic :: Internet :: WWW/HTTP",
+]
+dependencies = ["httpx>=0.27"]
+
+[project.optional-dependencies]
+pay = ["x402[httpx,requests,evm]>=2.25", "eth-account>=0.13"]
+langchain = ["langchain-core>=0.3"]
+crewai = ["crewai>=0.80"]
+
+[project.urls]
+Homepage = "https://shop.lordevo.com"
+Source = "https://github.com/forbot26/lordevo-x402"
+Issues = "https://github.com/forbot26/lordevo-x402/issues"
+Documentation = "https://shop.lordevo.com/llms.txt"
+
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["lordevo_x402"]
+
+[tool.hatch.build.targets.sdist]
+include = ["lordevo_x402", "tests", "README.md", "LICENSE", "pyproject.toml"]

lordevo_x402-0.1.0/tests/test_client.py

@@ -0,0 +1,82 @@
+"""Offline tests with httpx.MockTransport; nothing is paid."""
+import asyncio
+import base64
+import json
+
+import httpx
+import pytest
+
+import lordevo_x402 as L
+
+
+def test_tools_and_urls():
+    assert len(L.TOOLS) == 33
+    assert all(0.01 <= t["price_usd"] <= 0.03 for t in L.TOOLS.values())
+    assert L.tool_url("dns-lookup", "example.com", type="MX", junk="x") == "https://shop.lordevo.com/api/quick/dns-lookup?host=example.com&type=MX"
+    with pytest.raises(ValueError):
+        L.tool_url("email-validate")
+
+
+def test_sync_client_cap_cache_errors():
+    seen = []
+
+    def h(req):
+        seen.append(str(req.url))
+        if "ssl-cert" in str(req.url):
+            return httpx.Response(400, json={"error": "bad_host", "message": "Give a public host name", "charged": False})
+        return httpx.Response(200, json={"ok": True})
+
+    lo = L.LordevoSync(httpx.Client(transport=httpx.MockTransport(h)), max_price_usd=0.02, cache_seconds=60)
+    assert lo.can_fetch("https://example.com/a") == {"ok": True}
+    lo.can_fetch("https://example.com/a")
+    assert len(seen) == 1
+    with pytest.raises(ValueError, match="above max_price_usd"):
+        lo.site_check("example.com")
+    with pytest.raises(L.LordevoError) as e:
+        lo.ssl_cert("localhost")
+    assert e.value.status == 400 and e.value.charged is False
+
+
+def test_async_client():
+    async def go():
+        async def h(req):
+            return httpx.Response(200, json={"url": str(req.url)})
+        async with L.Lordevo(httpx.AsyncClient(transport=httpx.MockTransport(h))) as lo:
+            return await lo.dns_lookup("example.com", type="mx")
+    assert asyncio.run(go())["url"].endswith("dns-lookup?host=example.com&type=mx")
+
+
+def test_free_helpers():
+    pr = {"x402Version": 2, "accepts": [{"scheme": "exact", "network": "eip155:8453", "amount": "10000", "asset": "0xA", "payTo": "0xB"}]}
+
+    def h(req):
+        if req.url.path == "/a2a":
+            assert json.loads(req.content)["method"] == "message/send"
+            return httpx.Response(200, json={"jsonrpc": "2.0", "id": 1, "result": {"kind": "message", "role": "agent", "parts": [{"kind": "text", "text": "hi"}, {"kind": "data", "data": {"intent": "help"}}]}})
+        if req.url.path == "/catalog.json":
+            return httpx.Response(200, json={"quick_checks": []})
+        return httpx.Response(402, json={}, headers={"payment-required": base64.b64encode(json.dumps(pr).encode()).decode()})
+
+    c = httpx.Client(transport=httpx.MockTransport(h))
+    q = L.quote("dns-lookup", "example.com", client=c)
+    assert q["price_usd"] == 0.01 and q["network"] == "eip155:8453"
+    assert L.ask("help", client=c) == {"text": "hi", "intent": "help"}
+    assert L.catalog(client=c) == {"quick_checks": []}
+
+
+def test_langchain_tools_build():
+    pytest.importorskip("langchain_core")
+    from lordevo_x402.langchain import langchain_tools
+    lo = L.LordevoSync(httpx.Client(transport=httpx.MockTransport(lambda r: httpx.Response(200, json={"u": str(r.url)}))))
+    tools = langchain_tools(sync_client=lo, only=["dns-lookup", "can-fetch"])
+    assert [t.name for t in tools] == ["can_fetch", "dns_lookup"] or sorted(t.name for t in tools) == ["can_fetch", "dns_lookup"]
+    out = json.loads(next(t for t in tools if t.name == "dns_lookup").invoke({"host": "example.com", "type": "MX"}))
+    assert out["u"].endswith("host=example.com&type=MX")
+
+
+def test_crewai_tools_build():
+    pytest.importorskip("crewai")
+    from lordevo_x402.crewai import crewai_tools
+    lo = L.LordevoSync(httpx.Client(transport=httpx.MockTransport(lambda r: httpx.Response(200, json={"u": str(r.url)}))))
+    t = next(x for x in crewai_tools(lo, only=["dns-lookup"]) if x.name == "dns_lookup")
+    assert json.loads(t.run(host="example.com", type="MX"))["u"].endswith("host=example.com&type=MX")