@zeam-labs/x402-mcp-bridge 2.0.2 → 2.0.3

package/README.md

@@ -26,7 +26,7 @@ arguments this is still an MCP stdio server, which is what an MCP client wants.
 The server holds an idle line for **5000ms** and bills for that time. This client
 drops its own after **four tick intervals (1000ms)** of no use, so a pause costs
 you a reopen rather than four seconds of billing. So `closesAfterIdleMs: 5000` in
-`services.json` is the server's ceiling, not this client's behaviour — expect a
+`services.json` is the server's ceiling, not this client's behavior — expect a
 line to reopen during a slow session. `X402_LINE=off` pays per call instead.
 
 ## Why you need it
@@ -113,7 +113,7 @@ paying per call.
    That is an ordinary paid call and it buys the milliseconds since your previous
    tick.
 4. Every other call carries only `{line: "<credential>"}` and costs **nothing** —
-   no signature per call, nothing to serialise, and as many calls in flight at
+   no signature per call, nothing to serialize, and as many calls in flight at
    once as you like.
 
 Stop ticking and the line closes. An open line bills the whole time it is open,
@@ -132,7 +132,7 @@ If the server refuses a call because the line is gone — an ordinary rotate or
 idle close — the bridge **reopens the line and retries**, and only pays per call
 if that fails too. That ordering matters: falling straight through to per-call
 payment turns one closed line into a signed payment per in-flight call,
-serialised behind one channel, and when those run out of road they become unpaid
+serialized behind one channel, and when those run out of road they become unpaid
 requests that burn the hourly ceiling and lock a funded wallet out of its own
 channel. Measured before the fix, at 25-way concurrency: 3 of 12 calls served.
 After: 200 of 200 across 8 line deaths.
@@ -185,8 +185,8 @@ reaching it the line drops and further calls return
 Keep `X402_STATE_DIR` on disk. A client that reconnects to an existing channel
 with empty state pays a deposit it did not need, and can only recover if its
 signer can **read the chain** — so this bridge always gives the signer a reader.
-By default that reader is the upstream's own free `/bootstrap` surface, which
-means recovery costs nothing and needs no RPC of your own.
+By default that reader is the upstream's own free `/verify` surface, which means
+recovery costs nothing and needs no RPC of your own.
 
 Measured against `mcp.zeamprism.com`: fresh channel, first call 2.6s (one
 on-chain deposit) then ~180ms per call. State deliberately wiped: healed and

package/index.mjs

@@ -69,10 +69,12 @@ const stateDir = process.env.X402_STATE_DIR ??
   join(homedir(), '.x402-mcp-bridge', new URL(UPSTREAM).host, account.address.toLowerCase())
 mkdirSync(stateDir, { recursive: true })
 
+// The seller's free scoped RPC, last. It reaches their node without a wallet,
+// which is what makes it usable before you have paid them anything.
 const readers = [
   ...(process.env.X402_RPC_URL ? [process.env.X402_RPC_URL] : []),
   ...(chain.rpcUrls?.default?.http ?? []),
-  new URL('/bootstrap', UPSTREAM).toString(),
+  new URL('/verify', UPSTREAM).toString(),
 ]
 const pub = createPublicClient({ chain, transport: fallback(readers.map(u => http(u))) })
 log(`chain reads: ${readers.map(u => new URL(u).host).join(' -> ')}` +
@@ -191,6 +193,9 @@ log(`paying as ${account.address} -> ${UPSTREAM}`)
 const termsURL = new URL('/.well-known/x402', UPSTREAM).toString()
 let accepts = null
 let tickAccepts = null
+// The seller's line facts: how often to tick, and what a millisecond costs.
+// They belong to the service, not to one line, so they come from the manifest.
+let lineFacts = { tickMs: 250, microUSDPerMs: null }
 const loadTerms = async () => {
   const r = await fetch(termsURL)
   const j = await r.json()
@@ -199,6 +204,13 @@ const loadTerms = async () => {
   tickAccepts = Array.isArray(j.tickAccepts) && j.tickAccepts.length
     ? { x402Version: j.x402Version ?? 1, accepts: j.tickAccepts }
     : accepts                                    // an upstream that does not sell time
+  const ln = j.limits?.line ?? j.payment?.limits?.line
+  lineFacts = {
+    tickMs: Number(ln?.tickMs) > 0 ? Number(ln.tickMs) : lineFacts.tickMs,
+    microUSDPerMs: Number(j.rate?.microUSDPerMillisecond) > 0
+      ? Number(j.rate.microUSDPerMillisecond) : lineFacts.microUSDPerMs,
+  }
+
   const q = quoteFromTerms(j)
   if (q !== null) {
     if (q !== quoteMicroUSD) log(`quote: ${q} micro-USD per call, from the seller's own terms`)
@@ -351,12 +363,13 @@ const openLine = () => {
         clearTimeout(give_up)
         line.socket = socket
         line.credential = m.credential
-        line.tickMs = Number(m.tickMs) || 250
+        line.tickMs = lineFacts.tickMs
         // A line that has just opened has not been idle. lastUse starts at 0, so
         // without this the first timer fire sees an age of Date.now() and drops
         // the line before anything can use it.
         line.lastUse = Date.now()
-        log(`line open — ${m.microUSDPerMs ?? 1} micro-USD/ms, collateral buys ${m.buysMs ?? '?'}ms`)
+        log(`line open — ${lineFacts.microUSDPerMs ?? '?'} micro-USD/ms, ` +
+            `collateral buys ${m.buysMs ?? '?'}ms`)
         const first = tick()
         line.timer = setInterval(() => {
           // Stop paying for a line nobody is using. The server closes an unused
@@ -399,7 +412,14 @@ const callOnLine = async (name, args) => {
   // no payment, which is the one thing it cannot be. The server answered 402,
   // and the retry dropped a working line. It also has to share the queue with
   // our own ticker, or the two race and the channel refuses the loser as busy.
-  if (name === 'tick') return payFirst('tick', line.credential ? { line: line.credential } : args)
+  // A TICK NEEDS A LINE TO PAY FOR. Routing it straight to payFirst kept it off
+  // the line path, which is also the only thing that opens one -- so a client
+  // that funded and then only ticked never got a line and every tick was
+  // refused as matching none.
+  if (name === 'tick') {
+    if (!line.credential && channelId) await openLine()
+    return payFirst('tick', line.credential ? { line: line.credential } : args)
+  }
   if (LINE_MODE === 'off') return payFirst(name, args)
 
   if (LINE_MODE === 'auto') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeam-labs/x402-mcp-bridge",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "description": "Put a wallet in front of any x402-paid MCP server, and hold a metered line on the ones that sell time. Stock MCP clients cannot construct x402 payments; this one does, and proxies your existing client through it.",
   "type": "module",
   "bin": {