twzrd-mcp 0.1.0__tar.gz

twzrd_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: twzrd-mcp
+Version: 0.1.0
+Summary: Auto-pay MCP server for the TWZRD Trust API (Solana x402). Free preflight/lookup + auto-paid trust intel with spend caps. Payment path mainnet-proven via the official x402 SDK.
+Author: TWZRD
+License: MIT
+Project-URL: Homepage, https://intel.twzrd.xyz
+Project-URL: Repository, https://github.com/twzrd-sol/wzrd-final
+Keywords: mcp,model-context-protocol,x402,solana,twzrd,trust,agent,auto-pay,reputation
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Security
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: mcp>=1.0
+Requires-Dist: x402>=2.10
+Requires-Dist: requests>=2.31
+Requires-Dist: solders>=0.21
+
+# twzrd-mcp-server - auto-pay MCP for the TWZRD Trust API
+
+> Payment mechanism is mainnet-verified via the official x402 SDK (Python path,
+> $0.001 moved 2026-06-26 - see Status). The bundled TypeScript path stays
+> fail-closed until its hand-rolled header is replaced with the x402 JS SDK.
+
+Auto-pay MCP server for TWZRD's Trust API, matching the competitor GTM shape
+(anchor-x402, Br0ski777, BitBooth all ship one). An agent adds one `mcpServers`
+entry; paid tool calls auto-handle the x402 challenge. Free tools never pay.
+
+## Why this is a corrected rebuild
+A first draft signed **EIP-3009 on Base (EVM/viem)**. TWZRD settles x402 on
+**Solana** (`scheme:"exact"`, USDC, sponsored `feePayer`) — the EVM scheme never
+matches the challenge, so that draft could not pay TWZRD at all (it would `tsc`-pass
+yet fail every real call). This version is Solana-native and **refuses** any
+non-Solana challenge instead of mis-signing.
+
+## Safety guardrails (enforced before any signature)
+- Per-call cap `TWZRD_MAX_USDC_PER_CALL` (default 0.05)
+- Cumulative session cap `TWZRD_MAX_USDC_TOTAL` (default 1.00)
+- Free discovery tools never enter the payment path
+- No cross-chain fallback — a non-`exact`/non-`solana:` challenge is rejected
+- Paid calls run the free preflight first; `decision=block` aborts the pay
+
+## Status — payment path VERIFIED on mainnet 2026-06-26
+
+Two authorized settles from dev wallet `2pHjZLqs…`:
+
+1. **Hand-rolled `X-Payment` (this MCP's original approach): FAILED** — HTTP 402,
+   no USDC moved. The intel host validates via the official x402 lib's
+   `PaymentPayload`, so a hand-built header is rejected. (Green `tsc` ≠ settles —
+   fail-closed default was correct.)
+2. **Official x402 SDK: SUCCEEDED** — `GET /v1/intel/quick/CqtQPaAuQ5UR…` →
+   **HTTP 200, `"paid":true,"charged_amount_usdc":0.001`**, tier Silver score 53.6.
+   USDC balance moved `0.057236 → 0.056236` (exactly $0.001). A second call against
+   a no-data pubkey returned `422 charged:false` — the server's no-charge-on-empty
+   guard works.
+
+**Conclusion: auto-pay works ONLY via the official x402 SDK, not a hand-rolled
+header.** Proven client wiring (Python):
+
+```python
+from x402.client import x402ClientSync
+from x402.mechanisms.svm.signers import KeypairSigner
+from x402.mechanisms.svm.exact import register_exact_svm_client
+from x402.http.clients.requests import x402_requests
+client = x402ClientSync()
+register_exact_svm_client(client, KeypairSigner(keypair), rpc_url=RPC)
+session = x402_requests(client)
+session.get("https://intel.twzrd.xyz/v1/intel/quick/<wallet>")  # auto-pays $0.001
+```
+
+### Remaining work for THIS (TypeScript) MCP
+Replace the hand-rolled `payAndRetry` with the **x402 JS SDK** (SVM support) so the
+TS path matches the verified Python path. Note the x402 lib also ships an MCP module
+(`x402.mcp`) — a thin Python MCP over the proven client is the fastest route to a
+shippable auto-pay server. Keep the spend caps + preflight gate + free/paid split.
+Until the TS path is re-tested with the SDK it stays **fail-closed**; the **payment
+mechanism itself is now proven**.
+
+## Install & Config
+
+### Python (recommended — the mainnet-proven path)
+```bash
+pip install twzrd-mcp
+```
+MCP client config (`mcpServers`):
+```json
+{ "mcpServers": { "twzrd": {
+  "command": "twzrd-mcp",
+  "env": {
+    "TWZRD_RPC_URL": "<your Solana RPC url>",
+    "TWZRD_WALLET_KEYPAIR": "/path/to/solana-keypair.json",
+    "TWZRD_MCP_PAYMENTS_ENABLED": "1",
+    "TWZRD_MAX_USDC_PER_CALL": "0.05",
+    "TWZRD_MAX_USDC_TOTAL": "1.00"
+  }
+}}}
+```
+The **free** tools (`preflight`, `wallet_lookup`) need no wallet and no flags — leave
+`TWZRD_MCP_PAYMENTS_ENABLED` unset and they work read-only. Only the paid tools need
+the keypair + `TWZRD_MCP_PAYMENTS_ENABLED=1`.
+
+### Node (`npx twzrd-mcp-server`) — not yet shippable
+The bundled TypeScript path is **fail-closed** until its hand-rolled `X-Payment` header
+is replaced with the x402 JS SDK (see Status). Use the Python package above for working
+auto-pay today.
+
+## Tools
+- `preflight` (free) — allow/warn/block + trust_score before you pay
+- `wallet_lookup` (free) — facilitators + counterparty breadth for a Solana wallet
+- `quick_trust` ($0.001, auto-pay) — quick tier + score
+- `full_trust` ($0.05, auto-pay) — full trust intel + signed V6 receipt (verify offline with `twzrd-receipt-verifier`)

twzrd_mcp-0.1.0/README.md

@@ -0,0 +1,93 @@
+# twzrd-mcp-server - auto-pay MCP for the TWZRD Trust API
+
+> Payment mechanism is mainnet-verified via the official x402 SDK (Python path,
+> $0.001 moved 2026-06-26 - see Status). The bundled TypeScript path stays
+> fail-closed until its hand-rolled header is replaced with the x402 JS SDK.
+
+Auto-pay MCP server for TWZRD's Trust API, matching the competitor GTM shape
+(anchor-x402, Br0ski777, BitBooth all ship one). An agent adds one `mcpServers`
+entry; paid tool calls auto-handle the x402 challenge. Free tools never pay.
+
+## Why this is a corrected rebuild
+A first draft signed **EIP-3009 on Base (EVM/viem)**. TWZRD settles x402 on
+**Solana** (`scheme:"exact"`, USDC, sponsored `feePayer`) — the EVM scheme never
+matches the challenge, so that draft could not pay TWZRD at all (it would `tsc`-pass
+yet fail every real call). This version is Solana-native and **refuses** any
+non-Solana challenge instead of mis-signing.
+
+## Safety guardrails (enforced before any signature)
+- Per-call cap `TWZRD_MAX_USDC_PER_CALL` (default 0.05)
+- Cumulative session cap `TWZRD_MAX_USDC_TOTAL` (default 1.00)
+- Free discovery tools never enter the payment path
+- No cross-chain fallback — a non-`exact`/non-`solana:` challenge is rejected
+- Paid calls run the free preflight first; `decision=block` aborts the pay
+
+## Status — payment path VERIFIED on mainnet 2026-06-26
+
+Two authorized settles from dev wallet `2pHjZLqs…`:
+
+1. **Hand-rolled `X-Payment` (this MCP's original approach): FAILED** — HTTP 402,
+   no USDC moved. The intel host validates via the official x402 lib's
+   `PaymentPayload`, so a hand-built header is rejected. (Green `tsc` ≠ settles —
+   fail-closed default was correct.)
+2. **Official x402 SDK: SUCCEEDED** — `GET /v1/intel/quick/CqtQPaAuQ5UR…` →
+   **HTTP 200, `"paid":true,"charged_amount_usdc":0.001`**, tier Silver score 53.6.
+   USDC balance moved `0.057236 → 0.056236` (exactly $0.001). A second call against
+   a no-data pubkey returned `422 charged:false` — the server's no-charge-on-empty
+   guard works.
+
+**Conclusion: auto-pay works ONLY via the official x402 SDK, not a hand-rolled
+header.** Proven client wiring (Python):
+
+```python
+from x402.client import x402ClientSync
+from x402.mechanisms.svm.signers import KeypairSigner
+from x402.mechanisms.svm.exact import register_exact_svm_client
+from x402.http.clients.requests import x402_requests
+client = x402ClientSync()
+register_exact_svm_client(client, KeypairSigner(keypair), rpc_url=RPC)
+session = x402_requests(client)
+session.get("https://intel.twzrd.xyz/v1/intel/quick/<wallet>")  # auto-pays $0.001
+```
+
+### Remaining work for THIS (TypeScript) MCP
+Replace the hand-rolled `payAndRetry` with the **x402 JS SDK** (SVM support) so the
+TS path matches the verified Python path. Note the x402 lib also ships an MCP module
+(`x402.mcp`) — a thin Python MCP over the proven client is the fastest route to a
+shippable auto-pay server. Keep the spend caps + preflight gate + free/paid split.
+Until the TS path is re-tested with the SDK it stays **fail-closed**; the **payment
+mechanism itself is now proven**.
+
+## Install & Config
+
+### Python (recommended — the mainnet-proven path)
+```bash
+pip install twzrd-mcp
+```
+MCP client config (`mcpServers`):
+```json
+{ "mcpServers": { "twzrd": {
+  "command": "twzrd-mcp",
+  "env": {
+    "TWZRD_RPC_URL": "<your Solana RPC url>",
+    "TWZRD_WALLET_KEYPAIR": "/path/to/solana-keypair.json",
+    "TWZRD_MCP_PAYMENTS_ENABLED": "1",
+    "TWZRD_MAX_USDC_PER_CALL": "0.05",
+    "TWZRD_MAX_USDC_TOTAL": "1.00"
+  }
+}}}
+```
+The **free** tools (`preflight`, `wallet_lookup`) need no wallet and no flags — leave
+`TWZRD_MCP_PAYMENTS_ENABLED` unset and they work read-only. Only the paid tools need
+the keypair + `TWZRD_MCP_PAYMENTS_ENABLED=1`.
+
+### Node (`npx twzrd-mcp-server`) — not yet shippable
+The bundled TypeScript path is **fail-closed** until its hand-rolled `X-Payment` header
+is replaced with the x402 JS SDK (see Status). Use the Python package above for working
+auto-pay today.
+
+## Tools
+- `preflight` (free) — allow/warn/block + trust_score before you pay
+- `wallet_lookup` (free) — facilitators + counterparty breadth for a Solana wallet
+- `quick_trust` ($0.001, auto-pay) — quick tier + score
+- `full_trust` ($0.05, auto-pay) — full trust intel + signed V6 receipt (verify offline with `twzrd-receipt-verifier`)

twzrd_mcp-0.1.0/py/twzrd_mcp.egg-info/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: twzrd-mcp
+Version: 0.1.0
+Summary: Auto-pay MCP server for the TWZRD Trust API (Solana x402). Free preflight/lookup + auto-paid trust intel with spend caps. Payment path mainnet-proven via the official x402 SDK.
+Author: TWZRD
+License: MIT
+Project-URL: Homepage, https://intel.twzrd.xyz
+Project-URL: Repository, https://github.com/twzrd-sol/wzrd-final
+Keywords: mcp,model-context-protocol,x402,solana,twzrd,trust,agent,auto-pay,reputation
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Security
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: mcp>=1.0
+Requires-Dist: x402>=2.10
+Requires-Dist: requests>=2.31
+Requires-Dist: solders>=0.21
+
+# twzrd-mcp-server - auto-pay MCP for the TWZRD Trust API
+
+> Payment mechanism is mainnet-verified via the official x402 SDK (Python path,
+> $0.001 moved 2026-06-26 - see Status). The bundled TypeScript path stays
+> fail-closed until its hand-rolled header is replaced with the x402 JS SDK.
+
+Auto-pay MCP server for TWZRD's Trust API, matching the competitor GTM shape
+(anchor-x402, Br0ski777, BitBooth all ship one). An agent adds one `mcpServers`
+entry; paid tool calls auto-handle the x402 challenge. Free tools never pay.
+
+## Why this is a corrected rebuild
+A first draft signed **EIP-3009 on Base (EVM/viem)**. TWZRD settles x402 on
+**Solana** (`scheme:"exact"`, USDC, sponsored `feePayer`) — the EVM scheme never
+matches the challenge, so that draft could not pay TWZRD at all (it would `tsc`-pass
+yet fail every real call). This version is Solana-native and **refuses** any
+non-Solana challenge instead of mis-signing.
+
+## Safety guardrails (enforced before any signature)
+- Per-call cap `TWZRD_MAX_USDC_PER_CALL` (default 0.05)
+- Cumulative session cap `TWZRD_MAX_USDC_TOTAL` (default 1.00)
+- Free discovery tools never enter the payment path
+- No cross-chain fallback — a non-`exact`/non-`solana:` challenge is rejected
+- Paid calls run the free preflight first; `decision=block` aborts the pay
+
+## Status — payment path VERIFIED on mainnet 2026-06-26
+
+Two authorized settles from dev wallet `2pHjZLqs…`:
+
+1. **Hand-rolled `X-Payment` (this MCP's original approach): FAILED** — HTTP 402,
+   no USDC moved. The intel host validates via the official x402 lib's
+   `PaymentPayload`, so a hand-built header is rejected. (Green `tsc` ≠ settles —
+   fail-closed default was correct.)
+2. **Official x402 SDK: SUCCEEDED** — `GET /v1/intel/quick/CqtQPaAuQ5UR…` →
+   **HTTP 200, `"paid":true,"charged_amount_usdc":0.001`**, tier Silver score 53.6.
+   USDC balance moved `0.057236 → 0.056236` (exactly $0.001). A second call against
+   a no-data pubkey returned `422 charged:false` — the server's no-charge-on-empty
+   guard works.
+
+**Conclusion: auto-pay works ONLY via the official x402 SDK, not a hand-rolled
+header.** Proven client wiring (Python):
+
+```python
+from x402.client import x402ClientSync
+from x402.mechanisms.svm.signers import KeypairSigner
+from x402.mechanisms.svm.exact import register_exact_svm_client
+from x402.http.clients.requests import x402_requests
+client = x402ClientSync()
+register_exact_svm_client(client, KeypairSigner(keypair), rpc_url=RPC)
+session = x402_requests(client)
+session.get("https://intel.twzrd.xyz/v1/intel/quick/<wallet>")  # auto-pays $0.001
+```
+
+### Remaining work for THIS (TypeScript) MCP
+Replace the hand-rolled `payAndRetry` with the **x402 JS SDK** (SVM support) so the
+TS path matches the verified Python path. Note the x402 lib also ships an MCP module
+(`x402.mcp`) — a thin Python MCP over the proven client is the fastest route to a
+shippable auto-pay server. Keep the spend caps + preflight gate + free/paid split.
+Until the TS path is re-tested with the SDK it stays **fail-closed**; the **payment
+mechanism itself is now proven**.
+
+## Install & Config
+
+### Python (recommended — the mainnet-proven path)
+```bash
+pip install twzrd-mcp
+```
+MCP client config (`mcpServers`):
+```json
+{ "mcpServers": { "twzrd": {
+  "command": "twzrd-mcp",
+  "env": {
+    "TWZRD_RPC_URL": "<your Solana RPC url>",
+    "TWZRD_WALLET_KEYPAIR": "/path/to/solana-keypair.json",
+    "TWZRD_MCP_PAYMENTS_ENABLED": "1",
+    "TWZRD_MAX_USDC_PER_CALL": "0.05",
+    "TWZRD_MAX_USDC_TOTAL": "1.00"
+  }
+}}}
+```
+The **free** tools (`preflight`, `wallet_lookup`) need no wallet and no flags — leave
+`TWZRD_MCP_PAYMENTS_ENABLED` unset and they work read-only. Only the paid tools need
+the keypair + `TWZRD_MCP_PAYMENTS_ENABLED=1`.
+
+### Node (`npx twzrd-mcp-server`) — not yet shippable
+The bundled TypeScript path is **fail-closed** until its hand-rolled `X-Payment` header
+is replaced with the x402 JS SDK (see Status). Use the Python package above for working
+auto-pay today.
+
+## Tools
+- `preflight` (free) — allow/warn/block + trust_score before you pay
+- `wallet_lookup` (free) — facilitators + counterparty breadth for a Solana wallet
+- `quick_trust` ($0.001, auto-pay) — quick tier + score
+- `full_trust` ($0.05, auto-pay) — full trust intel + signed V6 receipt (verify offline with `twzrd-receipt-verifier`)

twzrd_mcp-0.1.0/py/twzrd_mcp.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+py/twzrd_mcp.py
+py/twzrd_mcp.egg-info/PKG-INFO
+py/twzrd_mcp.egg-info/SOURCES.txt
+py/twzrd_mcp.egg-info/dependency_links.txt
+py/twzrd_mcp.egg-info/entry_points.txt
+py/twzrd_mcp.egg-info/requires.txt
+py/twzrd_mcp.egg-info/top_level.txt

twzrd_mcp-0.1.0/py/twzrd_mcp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

twzrd_mcp-0.1.0/py/twzrd_mcp.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+twzrd-mcp = twzrd_mcp:main

twzrd_mcp-0.1.0/py/twzrd_mcp.egg-info/requires.txt

@@ -0,0 +1,4 @@
+mcp>=1.0
+x402>=2.10
+requests>=2.31
+solders>=0.21

twzrd_mcp-0.1.0/py/twzrd_mcp.egg-info/top_level.txt

@@ -0,0 +1 @@
+twzrd_mcp

twzrd_mcp-0.1.0/py/twzrd_mcp.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+"""TWZRD auto-pay MCP server (Python, Solana x402) — the VERIFIED shippable path.
+
+Uses the official x402 SDK client (ExactSvmClientScheme + KeypairSigner +
+x402_requests) — the exact wiring proven on mainnet 2026-06-26 ($0.001 settle,
+HTTP 200, paid:true). This is the part the hand-rolled TS draft got wrong: only
+the SDK produces a PaymentPayload the intel host accepts.
+
+Free tools never pay. Paid tools auto-pay via x402 with spend caps + preflight.
+
+ENV:
+  TWZRD_WALLET_KEYPAIR     path to a Solana keypair json (default ~/.config/solana/id.json)
+  TWZRD_RPC_URL            Solana RPC (required for signing)
+  TWZRD_API_URL            default https://intel.twzrd.xyz
+  TWZRD_MAX_USDC_PER_CALL  default 0.05
+  TWZRD_MAX_USDC_TOTAL     default 1.00
+  TWZRD_MCP_PAYMENTS_ENABLED  "1" to enable signing
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+
+import requests
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp.types import TextContent, Tool
+
+API_BASE = os.environ.get("TWZRD_API_URL", "https://intel.twzrd.xyz")
+MAX_PER_CALL = float(os.environ.get("TWZRD_MAX_USDC_PER_CALL", "0.05"))
+MAX_TOTAL = float(os.environ.get("TWZRD_MAX_USDC_TOTAL", "1.00"))
+PAYMENTS_ENABLED = os.environ.get("TWZRD_MCP_PAYMENTS_ENABLED") == "1"
+
+_paid_session: requests.Session | None = None
+_spent = 0.0
+
+
+def _build_paid_session() -> requests.Session:
+    """The verified x402 client wiring (mainnet-proven)."""
+    from solders.keypair import Keypair
+    from x402.client import x402ClientSync
+    from x402.mechanisms.svm.exact import register_exact_svm_client
+    from x402.mechanisms.svm.signers import KeypairSigner
+    from x402.http.clients.requests import x402_requests
+
+    kp_path = os.environ.get("TWZRD_WALLET_KEYPAIR", os.path.expanduser("~/.config/solana/id.json"))
+    rpc = os.environ.get("TWZRD_RPC_URL")
+    if not rpc:
+        raise RuntimeError("TWZRD_RPC_URL required for x402 signing")
+    kp = Keypair.from_bytes(bytes(json.load(open(kp_path))))
+    client = x402ClientSync()
+    register_exact_svm_client(client, KeypairSigner(kp), rpc_url=rpc)
+    return x402_requests(client)
+
+
+def _paid_get(path: str) -> str:
+    global _paid_session, _spent
+    if not PAYMENTS_ENABLED:
+        raise RuntimeError("Auto-pay disabled. Set TWZRD_MCP_PAYMENTS_ENABLED=1 to enable signing.")
+    # Per-call cap is enforced by refusing endpoints we know exceed it; cumulative
+    # cap is checked against MAX_TOTAL before the call. (Quick=$0.001, full=$0.05.)
+    price = 0.05 if "/trust/" in path else 0.001
+    if price > MAX_PER_CALL:
+        raise RuntimeError(f"Refusing: ${price} exceeds per-call cap ${MAX_PER_CALL}")
+    if _spent + price > MAX_TOTAL:
+        raise RuntimeError(f"Refusing: would exceed session cap ${MAX_TOTAL} (spent ${_spent})")
+    if _paid_session is None:
+        _paid_session = _build_paid_session()
+    r = _paid_session.get(f"{API_BASE}{path}", timeout=90)
+    body = r.text
+    # Only count spend when the server actually charged (it returns charged_amount_usdc).
+    try:
+        if json.loads(body).get("paid"):
+            _spent += float(json.loads(body).get("charged_amount_usdc", price))
+    except Exception:
+        pass
+    return body
+
+
+def _free(method: str, path: str, payload: dict | None = None) -> str:
+    if method == "POST":
+        return requests.post(f"{API_BASE}{path}", json=payload, timeout=30).text
+    return requests.get(f"{API_BASE}{path}", timeout=30).text
+
+
+app = Server("twzrd-mcp-server")
+
+TOOLS = [
+    Tool(name="preflight", description="FREE pre-pay check: allow/warn/block + trust_score.", inputSchema={"type": "object", "properties": {"seller_wallet": {"type": "string"}, "price_usdc": {"type": "number"}}, "required": ["seller_wallet"]}),
+    Tool(name="wallet_lookup", description="FREE: facilitators + counterparty breadth for a Solana wallet.", inputSchema={"type": "object", "properties": {"wallet": {"type": "string"}}, "required": ["wallet"]}),
+    Tool(name="quick_trust", description="PAID $0.001 (auto-pay x402, Solana): quick tier+score for a wallet.", inputSchema={"type": "object", "properties": {"wallet": {"type": "string"}}, "required": ["wallet"]}),
+    Tool(name="full_trust", description="PAID $0.05 (auto-pay x402, Solana): full trust intel + signed V6 receipt.", inputSchema={"type": "object", "properties": {"wallet": {"type": "string"}, "seller_wallet": {"type": "string"}}, "required": ["wallet"]}),
+]
+
+
+@app.list_tools()
+async def list_tools() -> list[Tool]:
+    return TOOLS
+
+
+@app.call_tool()
+async def call_tool(name: str, arguments: dict) -> list[TextContent]:
+    a = arguments or {}
+    if name == "preflight":
+        out = _free("POST", "/v1/intel/preflight", {"seller_wallet": a.get("seller_wallet"), "resource_name": "MCP", "price_usdc": a.get("price_usdc", 0.05)})
+    elif name == "wallet_lookup":
+        out = _free("GET", f"/v1/intel/get_facilitator_footprint?wallet={a['wallet']}")
+    elif name in ("quick_trust", "full_trust"):
+        # Preflight gate before paying (advisory; block aborts).
+        try:
+            card = json.loads(_free("POST", "/v1/intel/preflight", {"seller_wallet": a["wallet"], "resource_name": name, "price_usdc": 0.05 if name == "full_trust" else 0.001}))
+            if card.get("readiness_card", {}).get("decision") == "block":
+                return [TextContent(type="text", text=json.dumps({"refused": "preflight decision=block"}))]
+        except Exception:
+            pass
+        path = f"/v1/intel/quick/{a['wallet']}" if name == "quick_trust" else f"/v1/intel/trust/{a['wallet']}" + (f"?seller_wallet={a['seller_wallet']}" if a.get("seller_wallet") else "")
+        out = _paid_get(path)
+    else:
+        raise ValueError(f"Unknown tool: {name}")
+    return [TextContent(type="text", text=out)]
+
+
+async def _main() -> None:
+    async with stdio_server() as (r, w):
+        await app.run(r, w, app.create_initialization_options())
+
+
+def main() -> None:
+    """Console-script entry point (`twzrd-mcp`). Runs the stdio MCP server."""
+    asyncio.run(_main())
+
+
+if __name__ == "__main__":
+    main()

twzrd_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "twzrd-mcp"
+version = "0.1.0"
+description = "Auto-pay MCP server for the TWZRD Trust API (Solana x402). Free preflight/lookup + auto-paid trust intel with spend caps. Payment path mainnet-proven via the official x402 SDK."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "TWZRD" }]
+keywords = ["mcp", "model-context-protocol", "x402", "solana", "twzrd", "trust", "agent", "auto-pay", "reputation"]
+dependencies = [
+    "mcp>=1.0",
+    "x402>=2.10",
+    "requests>=2.31",
+    "solders>=0.21",
+]
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Intended Audience :: Developers",
+    "Topic :: Security",
+]
+
+[project.urls]
+Homepage = "https://intel.twzrd.xyz"
+Repository = "https://github.com/twzrd-sol/wzrd-final"
+
+[project.scripts]
+twzrd-mcp = "twzrd_mcp:main"
+
+[tool.setuptools]
+py-modules = ["twzrd_mcp"]
+
+[tool.setuptools.package-dir]
+"" = "py"

twzrd_mcp-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+