interline 0.1.0__py3-none-any.whl

interline-0.1.0.dist-info/METADATA

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: interline
+Version: 0.1.0
+Summary: Neutral, non-custodial MCP server that lets any AI agent pay across payment rails (x402 today, more landing) through one integration — rail-discovery + routing + a unified receipt ledger.
+License: MIT
+Keywords: mcp,model-context-protocol,x402,agent-payments,payment-router,agentic-payments,non-custodial,usdc,ai-agent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp>=1.0
+Requires-Dist: httpx>=0.28
+Requires-Dist: x402>=2.13
+Requires-Dist: eth-account>=0.13
+Requires-Dist: web3>=7.0
+Requires-Dist: fastapi>=0.110
+Provides-Extra: server
+Requires-Dist: uvicorn>=0.27; extra == "server"
+Dynamic: license-file
+
+# Interline (MCP server)
+
+**Rail-discovery + future-proof payments for AI agents — as an MCP server.**
+
+Two things your agent gets, **today**:
+1. **Discover** which payment rail(s) any paid endpoint accepts — *before* paying. (The discovery layer single-rail clients don't have.)
+2. **Pay** through it — non-custodial, your own key, capped.
+
+And the part that pays off across **every rail**: **integrate once.** Three rails are live today — [x402](https://x402.org) (HTTP 402 + USDC) on EVM (Base Sepolia) and on Solana (devnet), plus **MPP** on Tempo (Moderato testnet) — all behind the *same tool*. Real on-chain agent-to-agent settles are confirmed on all three. Every future rail drops in with **zero code change**. **Never re-integrate agent payments again** — when the next rail ships, your agent already speaks it.
+
+This is **not "another x402 MCP."** Single-rail clients make you wire up one rail (and re-wire for the next). This is the **discovery + routing layer above them** — same shape OpenRouter has for models. Non-custodial by design: payments use **your own wallet key**; this server never holds, sees, or routes funds through itself.
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `discover_payment_rails(url)` | Probe a paid endpoint; report **which rails + prices** it accepts. **No payment.** The discovery layer. |
+| `pay_for_resource(url, task, max_price_usdc)` | Pay + fetch through the accepted rail; return content **+ a settlement receipt**. Never exceeds `max_price_usdc`. |
+| `payment_history(limit)` | The **unified cross-rail receipt ledger** — every settlement, every rail, one view. |
+
+## Install
+
+```bash
+pip install interline        # (or: uvx interline)
+```
+
+### Add to Claude Desktop / Cursor / any MCP client
+
+```jsonc
+{
+  "mcpServers": {
+    "interline": {
+      "command": "uvx",
+      "args": ["interline"],
+      "env": {
+        "APV0_BUYER_PRIVATE_KEY": "0x...",   // YOUR wallet key — stays in your env, never leaves your machine
+        "APV0_NETWORK": "base-sepolia"        // or "base" for mainnet
+      }
+    }
+  }
+}
+```
+
+Local dev (from a clone):
+
+```jsonc
+{ "mcpServers": { "interline": {
+    "command": "python", "args": ["-m", "mcp_router.server"],
+    "cwd": "/path/to/interline-routes",
+    "env": { "APV0_BUYER_PRIVATE_KEY": "0x...", "APV0_NETWORK": "base-sepolia" }
+}}}
+```
+
+`discover_payment_rails` needs no key (it only reads the 402 challenge). `pay_for_resource` needs `APV0_BUYER_PRIVATE_KEY` (your funded wallet).
+
+## Non-custodial guarantee
+
+- The router **never holds funds.** `discover` only reads a public 402 challenge; `pay` signs with **your** key, locally, bounded by `max_price_usdc`.
+- The fee model (when one exists) is a **software/routing fee billed to you, the developer — never a cut of the funds flow.** That's the line between software (this) and money transmission (not this).
+
+## Status
+
+Three rails live — x402 USDC on EVM (Base Sepolia) and on Solana (devnet), plus MPP on Tempo (Moderato testnet). Real on-chain agent-to-agent settles confirmed on all three. Neutral by construction: `discover_payment_rails` surfaces *any* rail an endpoint offers, and each additional rail is a drop-in adapter with no caller change. Built on the [interline-routes](https://github.com/Choppaaahh/interline-routes) rail-agnostic core.

interline-0.1.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+interline-0.1.0.dist-info/licenses/LICENSE,sha256=lEOBkHaBtq9dL_66eHTx8uHWTOTA9ldZzSdmyOweYrs,1067
+mcp_router/README.md,sha256=uwE4iBuBJ5OJSEkvaWO9yBj6DcLtZrNCj7lYq9qFtBk,3325
+mcp_router/__init__.py,sha256=tfBBqEciI85AfxELWQ_utGAWeS6VIrkVQ0e9K1JanQ0,101
+mcp_router/discovery.py,sha256=E3LYz020e3J8-RL7kMXvegd1kfEeubpeyqVE9V2E-a4,7276
+mcp_router/selftest.py,sha256=-5T1nC_Q8ru9VrRzmepv5xHivwMQACDXo_Hom2qsvBw,6605
+mcp_router/server.py,sha256=lEJlJMa8rhHLU5fXpY6wnjBNEMjbGCNGR1nN_eI9L6U,3628
+router/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+router/buyer.py,sha256=RTUP0yiAkhhyeSPAcxMP2tHzVZ0eC-aWjUkWJ1RQxrg,2994
+router/config.py,sha256=kIV3YA4EUhGezFULV5vbCKbSNeEYLhik8YANFasafZM,4824
+router/facilitator_mock.py,sha256=_ZiysMS1YLTSFVv3qKPuW0VR8LsScMSjRtfNvOHjOB8,5523
+router/facilitator_real.py,sha256=KmEbK31LbZHsj5uPGf0jEWs5ajvmyab28VD6hDPyS7I,3057
+router/ledger.py,sha256=Zw0MM9tknVF07CPGrx-hxPMm2OIBeucVuqfOvw7iHuA,1134
+router/paywall.py,sha256=R-z_CygkGUdzZGR9ibPSTEkgev9oyGuiJcgtMBQ1HAY,7781
+router/seller.py,sha256=U1UXdDlIRxMIZTyL28Y0bkaOzkk_WjE1GKLnm2EO_uE,3645
+router/wallet.py,sha256=XGjGo6UeIyGzvUtP-cyj-yupNGilAcpaxq-y1PHF8tY,2695
+router/inbound/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+router/inbound/ap2_adapter.py,sha256=lYTJIG-a0IBniYMc1Fu_gXSFoCxZ0CuQgAcBA105bzM,10888
+router/rails/__init__.py,sha256=GUGMvk94xKRsOX60HpHE9JNyuyEQj6mWzyDHK326gbU,1791
+router/rails/base.py,sha256=xIrosBQAwhnETL4OlIIv2qHKS3SlaP4tcDRW6lbQaLk,1934
+router/rails/mpp_rail.py,sha256=2pFZmcNZopilePdOeOwwiVX8K7XENRaKC-sECxFMJOw,14923
+router/rails/x402_rail.py,sha256=4_tbHtrtMTNd-vqYEoJk2Kbz3PQ16XgviefbPGRvt-g,3220
+interline-0.1.0.dist-info/METADATA,sha256=RMV6gME4PwrB7nNT7O9ciftPiM9zxj9Dkr_b2MHRVQI,4052
+interline-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+interline-0.1.0.dist-info/entry_points.txt,sha256=hJ_eY4McNsKkhFEWbYezz2tGwKASbnGeMgI_Uh8UONE,53
+interline-0.1.0.dist-info/top_level.txt,sha256=VFm1NnWafoTx7THzUzVdKx1ZfZo0FsA6VLx-q4RzVzg,18
+interline-0.1.0.dist-info/RECORD,,

interline-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

interline-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+interline = mcp_router.server:main

interline-0.1.0.dist-info/licenses/LICENSE

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

interline-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+mcp_router
+router

mcp_router/README.md

@@ -0,0 +1,63 @@
+# Interline (MCP server)
+
+**Rail-discovery + future-proof payments for AI agents — as an MCP server.**
+
+Two things your agent gets, **today**:
+1. **Discover** which payment rail(s) any paid endpoint accepts — *before* paying. (The discovery layer single-rail clients don't have.)
+2. **Pay** through it — non-custodial, your own key, capped.
+
+And the part that pays off across **every rail**: **integrate once.** Three rails are live today — [x402](https://x402.org) (HTTP 402 + USDC) on EVM (Base Sepolia) and on Solana (devnet), plus **MPP** on Tempo (Moderato testnet) — all behind the *same tool*. Real on-chain agent-to-agent settles are confirmed on all three. Every future rail drops in with **zero code change**. **Never re-integrate agent payments again** — when the next rail ships, your agent already speaks it.
+
+This is **not "another x402 MCP."** Single-rail clients make you wire up one rail (and re-wire for the next). This is the **discovery + routing layer above them** — same shape OpenRouter has for models. Non-custodial by design: payments use **your own wallet key**; this server never holds, sees, or routes funds through itself.
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `discover_payment_rails(url)` | Probe a paid endpoint; report **which rails + prices** it accepts. **No payment.** The discovery layer. |
+| `pay_for_resource(url, task, max_price_usdc)` | Pay + fetch through the accepted rail; return content **+ a settlement receipt**. Never exceeds `max_price_usdc`. |
+| `payment_history(limit)` | The **unified cross-rail receipt ledger** — every settlement, every rail, one view. |
+
+## Install
+
+```bash
+pip install interline        # (or: uvx interline)
+```
+
+### Add to Claude Desktop / Cursor / any MCP client
+
+```jsonc
+{
+  "mcpServers": {
+    "interline": {
+      "command": "uvx",
+      "args": ["interline"],
+      "env": {
+        "APV0_BUYER_PRIVATE_KEY": "0x...",   // YOUR wallet key — stays in your env, never leaves your machine
+        "APV0_NETWORK": "base-sepolia"        // or "base" for mainnet
+      }
+    }
+  }
+}
+```
+
+Local dev (from a clone):
+
+```jsonc
+{ "mcpServers": { "interline": {
+    "command": "python", "args": ["-m", "mcp_router.server"],
+    "cwd": "/path/to/interline-routes",
+    "env": { "APV0_BUYER_PRIVATE_KEY": "0x...", "APV0_NETWORK": "base-sepolia" }
+}}}
+```
+
+`discover_payment_rails` needs no key (it only reads the 402 challenge). `pay_for_resource` needs `APV0_BUYER_PRIVATE_KEY` (your funded wallet).
+
+## Non-custodial guarantee
+
+- The router **never holds funds.** `discover` only reads a public 402 challenge; `pay` signs with **your** key, locally, bounded by `max_price_usdc`.
+- The fee model (when one exists) is a **software/routing fee billed to you, the developer — never a cut of the funds flow.** That's the line between software (this) and money transmission (not this).
+
+## Status
+
+Three rails live — x402 USDC on EVM (Base Sepolia) and on Solana (devnet), plus MPP on Tempo (Moderato testnet). Real on-chain agent-to-agent settles confirmed on all three. Neutral by construction: `discover_payment_rails` surfaces *any* rail an endpoint offers, and each additional rail is a drop-in adapter with no caller change. Built on the [interline-routes](https://github.com/Choppaaahh/interline-routes) rail-agnostic core.

mcp_router/__init__.py

@@ -0,0 +1 @@
+"""Interline — MCP server: let any MCP agent pay across payment rails (neutral, non-custodial)."""

mcp_router/discovery.py

@@ -0,0 +1,152 @@
+"""
+Rail discovery — given a paid endpoint, report which payment rails it accepts.
+
+THIS is the differentiator vs "another x402 payment MCP": one call tells an agent
+*every* way it could pay an endpoint, across whatever rails the endpoint offers —
+the neutral router's rail-discovery layer. Today x402 is live; as rails land (MPP, …)
+they surface in the same shape with zero caller change.
+
+The parse step (`parse_accepts`) is split from the network fetch (`discover_rails`) so
+the normalization is golden-fixture testable with no network.
+"""
+from __future__ import annotations
+
+import httpx
+
+# x402/MPP payment `scheme` → human rail name. Grows as rails land.
+# Unknown schemes fall through to themselves, so discovery still SURFACES a rail we don't
+# yet have a pretty name for (neutrality: report what's offered, don't hide it).
+SCHEME_TO_RAIL = {"exact": "x402", "mpp": "mpp"}
+
+# Default token decimals when not derivable from the challenge (USDC = 6).
+_DEFAULT_DECIMALS = 6
+
+
+def parse_accepts(body: dict) -> list[dict]:
+    """Pure: normalize an x402 402-challenge body's `accepts` array into a rail list."""
+    rails: list[dict] = []
+    for a in (body.get("accepts") or []):
+        scheme = a.get("scheme", "?")
+        extra = a.get("extra") or {}
+        amt = a.get("amount")
+        try:
+            human = f"{int(amt) / 10 ** _DEFAULT_DECIMALS:.6f} {extra.get('name', 'token')}"
+        except (TypeError, ValueError):
+            human = str(amt)
+        rails.append({
+            "rail": SCHEME_TO_RAIL.get(scheme, scheme),
+            "scheme": scheme,
+            "network": a.get("network"),
+            "asset": a.get("asset"),
+            "amount_atomic": amt,
+            "price": human,
+            "pay_to": a.get("payTo"),
+        })
+    return rails
+
+
+def discover_rails(url: str, timeout: float = 15.0) -> dict:
+    """GET `url`; if it returns a 402 challenge, report the rails it accepts. NO payment is made."""
+    try:
+        r = httpx.get(url, timeout=timeout, follow_redirects=True)
+    except Exception as e:  # noqa: BLE001 — surface the failure as data, don't raise into the agent
+        return {"url": url, "error": f"fetch failed: {e}", "rails": []}
+    if r.status_code != 402:
+        return {
+            "url": url, "paid": False, "status_code": r.status_code,
+            "note": "no 402 payment challenge (endpoint is free, or not an x402 resource)",
+            "rails": [],
+        }
+    try:
+        body = r.json()
+    except Exception:  # noqa: BLE001
+        return {"url": url, "paid": True, "error": "402 body was not JSON", "rails": []}
+    rails = parse_accepts(body)
+    return {
+        "url": url, "paid": True, "x402_version": body.get("x402Version"),
+        "rail_count": len(rails), "rails": rails,
+    }
+
+
+# ── known-rails capability registry ──────────────────────────────────────────
+# The neutral router is legible about the WHOLE landscape — including rails it does
+# NOT settle itself. `route_mode` is the honesty knob:
+#   native-settle = Interline settles this directly (x402) or via an inbound adapter
+#                   that lands on x402 (AP2). We move the funds.
+#   handoff       = Interline recognizes the protocol + routes an agent TO it, but does
+#                   NOT settle it — the protocol settles in its own world (Virtuals' own
+#                   x402 escrow; OpenAI/Stripe ACP's card-only delegated payment).
+KNOWN_RAILS = [
+    {
+        "name": "x402",
+        "kind": "settlement-rail",
+        "route_mode": "native-settle",
+        "networks": ["eip155 (EVM)", "solana (SVM)"],
+        "settle_asset": "USDC",
+        "what": "HTTP-402 micropayments. Interline settles natively across EVM + Solana behind one Paywall.",
+        "docs": "https://x402.org",
+    },
+    {
+        "name": "mpp",
+        "kind": "settlement-rail",
+        "route_mode": "native-settle",
+        "networks": ["tempo (stablecoin)"],
+        "settle_asset": "stablecoin",
+        "what": "Machine Payments Protocol (Stripe + Tempo, IETF draft-ryan-httpauth-payment). HTTP-402 "
+                "challenge/credential/receipt — convergent with x402, RFC-7235 framed. Interline settles it as "
+                "a second PROTOCOL behind the same Paywall (the cross-protocol wedge: pay an endpoint via x402 OR "
+                "mpp through one integration). Phase-1 runs the mock facilitator; live Tempo settle (official "
+                "pympp SDK) is gated on a funded Tempo wallet — no Stripe account required.",
+        "docs": "https://mpp.dev",
+    },
+    {
+        "name": "ap2",
+        "kind": "authorization-layer",
+        "route_mode": "native-settle",
+        "networks": ["eip155 (EVM)", "solana (SVM)"],
+        "settle_asset": "USDC",
+        "what": "Google Agent Payments Protocol — signed SD-JWT mandates. Interline's AP2 inbound adapter "
+                "verifies the mandate + constraints + freshness, then settles on x402. One seam for the "
+                "card/agent-commerce tier (UCP / Mastercard / Amex / PayPal all delegate to AP2).",
+        "docs": "https://github.com/google-agentic-commerce/AP2",
+    },
+    {
+        "name": "virtuals-acp",
+        "kind": "commerce-ecosystem",
+        "route_mode": "handoff",
+        "networks": ["eip155:8453 (Base)"],
+        "settle_asset": "USDC",
+        "what": "Virtuals Protocol Agent Commerce Protocol — a crypto-native agent marketplace running its OWN "
+                "x402 rail + on-chain escrow on Base. Interline routes an agent to it (handoff); it settles in "
+                "its own ecosystem, not ours. Python SDK: virtuals-acp.",
+        "docs": "https://whitepaper.virtuals.io/about-virtuals/agent-commerce-protocol-acp",
+    },
+    {
+        "name": "openai-stripe-acp",
+        "kind": "commerce-layer",
+        "route_mode": "handoff",
+        "networks": ["card / PSP networks"],
+        "settle_asset": "fiat (card)",
+        "what": "OpenAI/Stripe Agentic Commerce Protocol (ChatGPT Instant Checkout). Its delegated payment is "
+                "CARD-ONLY (payment_method_type=card, settled through PSP/card networks), so Interline routes an "
+                "agent to it (handoff) — our crypto rail can't be the settlement target.",
+        "docs": "https://github.com/agentic-commerce-protocol/agentic-commerce-protocol",
+    },
+]
+
+
+def known_rails_catalog() -> dict:
+    """The neutral router's full rail catalog — what Interline knows about + how it relates to each.
+
+    Separates rails Interline SETTLES natively (route_mode=native-settle: x402, AP2-via-adapter) from
+    protocols it ROUTES an agent to but does not settle (route_mode=handoff: Virtuals' own x402 escrow,
+    OpenAI/Stripe ACP's card-only delegated payment). Legibility over the whole landscape — reporting
+    every rail, including ones we don't move funds on — IS the neutral-router thesis."""
+    settles = [r["name"] for r in KNOWN_RAILS if r["route_mode"] == "native-settle"]
+    handoffs = [r["name"] for r in KNOWN_RAILS if r["route_mode"] == "handoff"]
+    return {
+        "rail_count": len(KNOWN_RAILS),
+        "native_settle": settles,
+        "handoff": handoffs,
+        "rails": KNOWN_RAILS,
+    }

mcp_router/selftest.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""
+MCP-router self-test — NO network, NO keys. Golden-fixture verified.
+
+Proves:
+  1. parse_accepts normalizes a single-rail x402 402 body (golden: 1000 atomic -> "0.001000 USDC").
+  2. parse_accepts is NEUTRAL — surfaces a SECOND, unknown-scheme rail (proves discovery isn't x402-only).
+  3. parse_accepts on empty/no-accepts -> 0 rails (no crash).
+  4. discover_rails routes: 402 -> rails parsed; 200 -> paid=False; fetch-error -> error surfaced.
+  5. payment_history reads the ledger shape.
+
+Run from repo root: python -m mcp_router.selftest
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from mcp_router import discovery  # noqa: E402
+
+FAILS = []
+
+
+def check(name, cond):
+    print(f"  {'PASS' if cond else 'FAIL'}  {name}")
+    if not cond:
+        FAILS.append(name)
+
+
+# --- GOLDEN FIXTURES (CC-computed, asserted verbatim — model must not recompute) ---
+# single x402 rail: amount 1000 atomic / 1e6 = 0.001 USDC
+GOLDEN_SINGLE = {
+    "x402Version": 2,
+    "accepts": [
+        {"scheme": "exact", "network": "eip155:84532", "asset": "0xUSDC",
+         "amount": "1000", "payTo": "0xSELLER", "extra": {"name": "USDC"}},
+    ],
+}
+# multi-rail: x402 (1000 -> 0.001) + an unknown "mpp" scheme (5000 -> 0.005)
+GOLDEN_MULTI = {
+    "x402Version": 2,
+    "accepts": [
+        {"scheme": "exact", "network": "eip155:84532", "amount": "1000", "payTo": "0xA", "extra": {"name": "USDC"}},
+        {"scheme": "mpp", "network": "eip155:8453", "amount": "5000", "payTo": "0xB", "extra": {"name": "USDC"}},
+    ],
+}
+
+
+class FakeResp:
+    def __init__(self, status, payload=None, raise_json=False):
+        self.status_code = status
+        self._payload = payload
+        self._raise = raise_json
+
+    def json(self):
+        if self._raise:
+            raise ValueError("not json")
+        return self._payload
+
+
+def main():
+    # 1. single-rail golden
+    rails = discovery.parse_accepts(GOLDEN_SINGLE)
+    check("single-rail -> 1 rail", len(rails) == 1)
+    check("single-rail scheme exact -> rail x402", rails[0]["rail"] == "x402")
+    check("single-rail price = 0.001000 USDC (golden)", rails[0]["price"] == "0.001000 USDC")
+    check("single-rail pay_to passthrough", rails[0]["pay_to"] == "0xSELLER")
+    check("single-rail amount_atomic passthrough", rails[0]["amount_atomic"] == "1000")
+
+    # 2. multi-rail neutrality — unknown scheme surfaced as its own rail
+    rails = discovery.parse_accepts(GOLDEN_MULTI)
+    check("multi-rail -> 2 rails", len(rails) == 2)
+    check("multi-rail surfaces unknown 'mpp' scheme as rail", rails[1]["rail"] == "mpp")
+    check("multi-rail mpp price = 0.005000 USDC (golden)", rails[1]["price"] == "0.005000 USDC")
+    check("multi-rail networks distinct", rails[0]["network"] != rails[1]["network"])
+
+    # 3. empty / malformed
+    check("no-accepts -> 0 rails", discovery.parse_accepts({}) == [])
+    check("null-accepts -> 0 rails", discovery.parse_accepts({"accepts": None}) == [])
+    bad_amt = discovery.parse_accepts({"accepts": [{"scheme": "exact", "amount": None}]})
+    check("None amount -> price is string, no crash", bad_amt[0]["price"] == "None")
+
+    # 4. discover_rails routing (monkeypatch httpx.get)
+    orig = discovery.httpx.get
+    try:
+        discovery.httpx.get = lambda url, **kw: FakeResp(402, GOLDEN_SINGLE)
+        d = discovery.discover_rails("http://x/work")
+        check("402 -> paid True + 1 rail", d.get("paid") is True and d.get("rail_count") == 1)
+
+        discovery.httpx.get = lambda url, **kw: FakeResp(200, {"work": "free"})
+        d = discovery.discover_rails("http://x/free")
+        check("200 -> paid False", d.get("paid") is False and d.get("rails") == [])
+
+        def _raise(url, **kw):
+            raise RuntimeError("conn refused")
+        discovery.httpx.get = _raise
+        d = discovery.discover_rails("http://x/down")
+        check("fetch error -> error surfaced as data", "error" in d and d["rails"] == [])
+
+        discovery.httpx.get = lambda url, **kw: FakeResp(402, None, raise_json=True)
+        d = discovery.discover_rails("http://x/badjson")
+        check("402 non-JSON -> error surfaced", "error" in d)
+    finally:
+        discovery.httpx.get = orig
+
+    # 5. payment_history shape (import server lazily; ledger may be empty)
+    from mcp_router import server  # noqa: F401
+    hist = server.payment_history(limit=5)
+    check("payment_history returns count+settlements", "count" in hist and "settlements" in hist)
+
+    # 6. known-rails catalog (GOLDEN — neutral landscape, settle-vs-handoff honesty)
+    cat = discovery.known_rails_catalog()
+    check("catalog has 5 known rails", cat["rail_count"] == 5)
+    check("native_settle = [x402, mpp, ap2] (golden)", cat["native_settle"] == ["x402", "mpp", "ap2"])
+    check("handoff = [virtuals-acp, openai-stripe-acp] (golden)",
+          cat["handoff"] == ["virtuals-acp", "openai-stripe-acp"])
+    by = {r["name"]: r for r in cat["rails"]}
+    check("x402 is native-settle", by["x402"]["route_mode"] == "native-settle")
+    check("mpp is native-settle (the cross-protocol wedge)", by["mpp"]["route_mode"] == "native-settle")
+    check("mpp is a settlement-rail (a 2nd protocol, not an authz layer)", by["mpp"]["kind"] == "settlement-rail")
+    check("ap2 is native-settle", by["ap2"]["route_mode"] == "native-settle")
+    check("virtuals-acp is handoff (its own x402 escrow)", by["virtuals-acp"]["route_mode"] == "handoff")
+    # honesty assertion: ACP is card-only -> handoff, NOT a crypto rail we settle
+    check("openai-stripe-acp is handoff", by["openai-stripe-acp"]["route_mode"] == "handoff")
+    check("openai-stripe-acp settle_asset is fiat/card (NOT crypto — honesty)",
+          "card" in by["openai-stripe-acp"]["settle_asset"].lower() or "fiat" in by["openai-stripe-acp"]["settle_asset"].lower())
+    required = {"name", "kind", "route_mode", "networks", "settle_asset", "what", "docs"}
+    check("every rail has full metadata", all(required <= set(r) for r in cat["rails"]))
+    check("every route_mode is native-settle or handoff",
+          all(r["route_mode"] in ("native-settle", "handoff") for r in cat["rails"]))
+    # the MCP tool returns the same catalog
+    check("server.list_known_rails tool == catalog", server.list_known_rails() == cat)
+
+    print()
+    if FAILS:
+        print(f"SELF-TEST FAIL: {len(FAILS)} -> {FAILS}")
+        sys.exit(1)
+    print("SELF-TEST PASS — MCP router discovery (neutral multi-rail) + history wired, golden-fixture verified.")
+
+
+if __name__ == "__main__":
+    main()

mcp_router/server.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""
+Interline — an MCP server that lets ANY MCP-using agent pay across payment rails.
+
+Three tools:
+  discover_payment_rails(url)               — probe a paid endpoint; report which rails + prices it accepts (NO payment)
+  pay_for_resource(url, task, max_usd)      — pay + fetch through the accepted rail; return content + receipt
+  payment_history(limit)                    — the unified cross-rail receipt ledger
+
+NEUTRAL by design: discovery reports EVERY rail an endpoint offers (today x402; MPP/others drop
+into the same shape). NON-CUSTODIAL: payment uses the CALLER'S OWN wallet key (env), never ours.
+
+Run as a stdio MCP server:  python -m mcp_router.server   (or the `interline` entry point)
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+# Make `router` importable whether run from the repo root or as an installed entry point.
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from mcp.server.fastmcp import FastMCP  # noqa: E402
+from mcp_router.discovery import discover_rails, known_rails_catalog  # noqa: E402
+
+mcp = FastMCP("interline")
+
+
+@mcp.tool()
+def discover_payment_rails(url: str) -> dict:
+    """Probe a paid endpoint and report which payment rails it accepts + the price for each — WITHOUT paying.
+
+    The neutral rail-discovery layer: one call tells your agent every way it could pay this endpoint,
+    across whatever rails the endpoint offers. Use this before pay_for_resource to see the price/rails."""
+    return discover_rails(url)
+
+
+@mcp.tool()
+def pay_for_resource(url: str, task: str = "", max_price_usdc: float = 0.01) -> dict:
+    """Pay for and fetch a paywalled resource, returning its content + a settlement receipt.
+
+    Routes the payment through the rail the endpoint accepts; never pays more than max_price_usdc.
+    Uses the caller's OWN wallet key from APV0_BUYER_PRIVATE_KEY (non-custodial — this server never
+    holds or sees funds). `task` is appended as a query param for endpoints that take one."""
+    from router import buyer  # local import: only needed on the pay path
+
+    max_atomic = int(round(max_price_usdc * 10 ** 6))
+    full_url = url if not task else f"{url}{'&' if '?' in url else '?'}task={task}"
+    try:
+        result = buyer.pay_and_get(full_url, max_price_atomic=max_atomic)
+        return {"ok": True, **result}
+    except Exception as e:  # noqa: BLE001
+        return {"ok": False, "error": str(e)}
+
+
+@mcp.tool()
+def list_known_rails() -> dict:
+    """List EVERY agent-payment rail/protocol Interline knows about + how it relates to each — the neutral catalog.
+
+    Separates rails Interline SETTLES natively (route_mode=native-settle: x402, AP2-via-adapter) from protocols
+    it ROUTES you TO but does not settle (route_mode=handoff: Virtuals ACP's own on-chain escrow, OpenAI/Stripe
+    ACP's card-only delegated payment). One call = the whole agent-payment landscape, including the rails we
+    don't move funds on. Pair with discover_payment_rails (what a specific endpoint accepts)."""
+    return known_rails_catalog()
+
+
+@mcp.tool()
+def payment_history(limit: int = 20) -> dict:
+    """Return the most recent cross-rail settlement receipts — the unified ledger across every rail paid through."""
+    from router import ledger  # local import
+
+    p = ledger.LEDGER
+    if not p.exists():
+        return {"count": 0, "settlements": []}
+    rows = [json.loads(ln) for ln in p.read_text().splitlines() if ln.strip()]
+    return {"count": len(rows), "settlements": rows[-limit:]}
+
+
+def main() -> None:
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()