@curless/sinocare-demo 0.55.0

package/dist/index.js

@@ -0,0 +1,2262 @@
+#!/usr/bin/env node
+// Buyer-side AP2: sign the PaymentMandate as a real ES256 JWS bound to the cart.
+import { createHash } from 'node:crypto';
+import { readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+// Buyer-side MPP · Tempo — parse the 402 challenge, pay the on-chain TIP-20
+// transfer, build the Payment credential. Same SDK, different subpath.
+import { completeCheckout, purchaseOf, readCheckoutSession, totalOf, } from '@curless/agentbank-protocols/acp';
+import { signIntentMandate, signPaymentMandate, } from '@curless/agentbank-protocols/ap2';
+// Buyer-side USDC-over-Solana x402 — build + partially sign an SPL transfer, the
+// facilitator co-signs feePayer + submits. Same SDK, different subpath.
+import { addressFromSecretKey, secretKeyFromString, signSolanaX402Payment, } from '@curless/agentbank-protocols/solana';
+import { payMppTempoChallenge } from '@curless/agentbank-protocols/tempo';
+// Buyer-side x402 lives in the SDK — sign EIP-3009, encode X-PAYMENT, read USDC
+// balance. The demo never hand-rolls the signing.
+import { cdpAccountSigner, encodeXPaymentHeader, signX402Payment, signerFromPrivateKey, usdcBalance, } from '@curless/agentbank-protocols/x402';
+// Buyer-side RLUSD/XRPL x402 — sign an Ed25519 Payment, encode X-PAYMENT. Same
+// SDK, different subpath. encodeXPaymentHeader collides with /x402's, so alias it.
+import { encodeXPaymentHeader as encodeXrplXPaymentHeader, signXrplPayment, } from '@curless/agentbank-protocols/xrpl';
+import { createBuyerSession } from '@curless/agentbank-sdk';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { generatePrivateKey } from 'viem/accounts';
+import { Client as XrplClient, Wallet as XrplWallet } from 'xrpl';
+// The checkout MCP App card (a single self-contained HTML), built from
+// examples/sinocare-demo/widget and served as a ui:// resource.
+import { CHECKOUT_CARD_HTML } from './checkout-card.generated.js';
+// @curless/sinocare-demo — a SIMULATED "Sinocare" storefront MCP for the BUYER.
+// Booking is end-to-end agentic:
+//   1. browse + start a booking via Sinocare's merchant backend
+//      (mcp.curless.ai/sinocare) — the merchant prices it and opens a
+//      merchant-quoted ACP checkout session with its own key;
+//   2. THIS buyer agent completes the charge over ACP with its own payment
+//      credential (test card) — the merchant set the price, the agent pays.
+// The storefront never sees the merchant's key; it holds only its OWN buyer
+// token, exactly like a real agent buyer.
+//
+// Run (Claude Desktop / any MCP client):
+//   npx -y @curless/sinocare-demo
+// with env:
+//   AGENTBANK_AGENT_TOKEN   the buyer's agentbank agent key (agb_…, agent:execute).
+//   SINOCARE_BUYER_NAME / SINOCARE_BUYER_EMAIL  who this agent buys for (optional;
+//                            unset = anonymous bookings, as before)
+//                           Use a TEST, no-org key (the demo org is shared).
+//   AGENTBANK_API_URL       base URL (default https://mcp.curless.ai; set
+//                           http://localhost:3000 for local dev).
+//   AGENTBANK_PAYMENT_TOKEN delegated card token (default pm_card_visa).
+//   Real ACP credential (optional) — mint a Shared Payment Token per booking
+//   instead of reusing a plain card token. This is what a buyer's WALLET does
+//   when an agent asks to spend: the token is scoped to one seller, one amount,
+//   one currency and a short expiry, so it can buy nothing else.
+//     STRIPE_AGENT_SECRET_KEY  the BUYER side's Stripe key (the wallet's PSP).
+//                              Must be a DIFFERENT Stripe account from the
+//                              seller's — an SPT cannot be granted to yourself.
+//     AGENTBANK_SELLER_PROFILE the seller's Stripe profile id (profile_…) that
+//                              the gateway redeems with.
+//     STRIPE_AGENT_PAYMENT_METHOD  optional pm_… to mint from; in test mode a
+//                              throwaway one is created from tok_visa.
+//   Set all of these and buy_sinocare_product_acp pays with a real spt_; leave
+//   them unset and it falls back to AGENTBANK_PAYMENT_TOKEN.
+//   Two guards, both OFF by default — a booking here is one click in the card,
+//   and a Sinocare room is €1,280–2,900:
+//     SINOCARE_ALLOW_LIVE_WALLET=1  allow minting with a LIVE key (REAL money).
+//     SINOCARE_WALLET_FALLBACK=1    if minting fails, pay with the plain card
+//                                  token instead of failing the booking.
+//   Without them a live key refuses to mint, and a mint failure fails the
+//   booking rather than silently paying with an unscoped credential.
+//   x402 USDC (EVM) — pick ONE signer:
+//     X402_SIGNER=cdp        a CDP Server Wallet, zero raw key (for MAINNET);
+//                            needs CDP_API_KEY_ID/_SECRET/_WALLET_SECRET.
+//     X402_PAYER_PRIVATE_KEY a local funded wallet key (testnet or mainnet).
+//   The gateway's mode (test/live key) decides the network it quotes; fund the
+//   buyer wallet with USDC on that network.
+//   x402 RLUSD (XRP Ledger) — for buy_sinocare_product_rlusd / xrpl_buyer_wallet:
+//     XRPL_BUYER_SEED        an `sEd…` testnet seed (Ed25519) holding RLUSD + a
+//                            little test XRP for the fee/reserve.
+//     XRPL_TESTNET_WSS       RPC (default wss://s.altnet.rippletest.net:51233).
+//     XRPL_RLUSD_ISSUER      RLUSD issuer r-address (default = testnet issuer).
+//
+// IMPORTANT: only JSON-RPC may be written to stdout (the MCP stdio transport).
+// Never console.log here — diagnostics go to stderr.
+const API_BASE = (process.env.AGENTBANK_API_URL ?? 'https://mcp.curless.ai').replace(/\/$/, '');
+const SINOCARE = `${API_BASE}/sinocare`;
+// The buyer's ACP client. Every booking below reads the session's real total
+// and completes through this rather than hand-writing /acp/... — the two calls
+// were written out twice already, and both copies re-derived that the
+// authoritative amount is on the session, not in the backend's display string.
+const acp = (merchantId) => {
+    // Throw rather than send an empty bearer. Every caller below already refuses
+    // to open a checkout without a token, so reaching here without one is a bug
+    // in this file — and an empty Authorization header would surface as a 401
+    // from the gateway, which reads like a credential problem on the buyer's end.
+    if (!TOKEN)
+        throw new Error('AGENTBANK_AGENT_TOKEN is not set');
+    return { baseUrl: API_BASE, merchantId, token: TOKEN };
+};
+const TOKEN = process.env.AGENTBANK_AGENT_TOKEN;
+// WHO this agent is buying for. A buyer agent is the only party that knows its
+// user's identity — the merchant never meets them — so it is the only place this
+// can enter the system. Sent on every checkout, and from there it reaches the
+// order, the card provider's customer record, the Curless mirror and the Shopify
+// order.
+//
+// Unset → nothing is sent, and every booking stays anonymous exactly as before.
+// Deliberately NOT defaulted to a placeholder: a fabricated buyer would travel
+// into a merchant's financial records and Shopify would email the address.
+const BUYER = (() => {
+    const name = process.env.SINOCARE_BUYER_NAME?.trim();
+    const email = process.env.SINOCARE_BUYER_EMAIL?.trim();
+    if (!name && !email)
+        return undefined;
+    return { ...(name ? { name } : {}), ...(email ? { email } : {}) };
+})();
+const PAYMENT_TOKEN = process.env.AGENTBANK_PAYMENT_TOKEN ?? 'pm_card_visa';
+const STRIPE_AGENT_KEY = process.env.STRIPE_AGENT_SECRET_KEY;
+const SELLER_PROFILE = process.env.AGENTBANK_SELLER_PROFILE;
+// The BUYER's Curless wallet, signed into at runtime by the person booking —
+// not configuration. Two ways to pay by card now sit side by side: the agent's
+// own Stripe key (STRIPE_AGENT_SECRET_KEY above, the demo's original path), and
+// this, where the credential is minted from the card the buyer bound and capped
+// by the limits the buyer set. Both stay: the wallet is the one being built,
+// and the agent-key path is what still works when nobody has signed in.
+const wallet = createBuyerSession({ baseUrl: API_BASE });
+// One browser sign-in at a time, shared by whoever asks. Two cards (or a card
+// and the model) each starting their own would show the person two different
+// codes for the same wallet, and only one of them would ever complete.
+let pending = null;
+/**
+ * The signed-in wallet owner, as a buyer block — or undefined when nobody is
+ * signed in (the agent-key ACP path, which keeps SINOCARE_BUYER_EMAIL).
+ */
+const walletBuyer = () => {
+    const who = wallet.current();
+    if (!who)
+        return undefined;
+    return { buyer: { email: who.email, ...(who.name ? { name: who.name } : {}) } };
+};
+// Whether a sign-in was ever STARTED here. `pending` alone cannot say: it is
+// null both before anyone begins and after one times out, and reporting those
+// two as the same thing is how "nobody has signed in yet" got told to someone
+// as "your code expired".
+let loginEverStarted = false;
+const pendingLogin = async () => {
+    if (pending)
+        return pending;
+    const started = await wallet.startDeviceLogin();
+    pending = started;
+    loginEverStarted = true;
+    // The session adopts itself when the person finishes; this just clears the
+    // slot so a later sign-in starts fresh. Errors are the poller's to report —
+    // swallowing them here would leave a dead login pinned forever.
+    started
+        .wait()
+        .catch(() => undefined)
+        .finally(() => {
+        pending = null;
+    });
+    return started;
+};
+// The gateway's spend-policy reasons, said to the PERSON. Mirrors the codes
+// `evaluatePolicy` emits; anything unmapped falls through to the gateway's own
+// wording rather than being swallowed, so a new code shows up as English text
+// instead of disappearing.
+// The gateway's refusals, said to the PERSON — each with its OWN next step.
+// One shared "想付的话可以先调高限额" tail was wrong for every reason that is
+// not a limit: it told someone whose wallet has no card at all to go raise a
+// cap, which sends them to the wrong screen and leaves the actual problem
+// unmentioned.
+const REFUSALS = [
+    [/per_transaction_limit/, '超过了你设的单笔上限', '可以在钱包里调高单笔上限。'],
+    [/daily_limit/, '超过了你设的当日上限', '可以调高当日上限,或者明天再来。'],
+    [/monthly_limit/, '超过了你设的当月上限', '可以调高当月上限,或者下个月再来。'],
+    [/merchant_not_allowed/, '这个商家不在你的白名单里', '把它加进白名单就能付。'],
+    [/mcc_not_allowed/, '这个商家类别不在你的白名单里', '把这个类别加进白名单就能付。'],
+    [
+        /no approval step yet/,
+        '金额超过了你设的"需要我批准"的门槛,而现在还没有审批环节',
+        '把这个门槛调高或清掉就能付。',
+    ],
+    [/no card is bound/, '这个钱包还没绑卡', '去钱包页面绑一张卡再回来付。'],
+];
+// A wallet refusal is not a payment failure, and the difference matters to the
+// person: nothing was charged. Rendered through the card's `message`, so it has
+// to be JSON and it has to be readable.
+const walletRefusal = (err) => {
+    const raw = err.message;
+    const hit = REFUSALS.find(([re]) => re.test(raw));
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    walletRefused: true,
+                    message: hit
+                        ? `钱包没付这笔 —— ${hit[1]}。没有扣款。${hit[2]}`
+                        : `钱包没付这笔:${raw}。没有扣款。`,
+                    // The wallet page is where every one of these is fixed, so the card
+                    // can hand the person somewhere to go rather than a dead end.
+                    walletUrl: `${API_BASE}/buyer/wallet`,
+                    next: "this is the BUYER'S OWN limit, not a payment failure. Tell them which limit stopped it and offer to raise it with wallet_set_limits — do NOT retry with another payment method.",
+                }),
+            },
+        ],
+        isError: true,
+    };
+};
+const AGENT_PM = process.env.STRIPE_AGENT_PAYMENT_METHOD;
+const STRIPE_AGENT_SECRET_KEY_IS_LIVE = !!STRIPE_AGENT_KEY?.startsWith('sk_live_');
+// Two deliberate escape hatches, both off by default:
+//   SINOCARE_ALLOW_LIVE_WALLET=1 — mint with a live key (real money, see below).
+//   SINOCARE_WALLET_FALLBACK=1   — if minting fails, pay with the plain card
+//                                 token anyway instead of failing the booking.
+const WALLET_LIVE_OK = process.env.SINOCARE_ALLOW_LIVE_WALLET === '1';
+const WALLET_FALLBACK_OK = process.env.SINOCARE_WALLET_FALLBACK === '1';
+// Mint a REAL ACP Shared Payment Token for exactly this booking — the buyer
+// wallet's half of agentic commerce. Scoped to the seller's profile, this
+// amount, this currency, 15 minutes; the agent can spend it nowhere else.
+// Returns null when the wallet side isn't configured, so the demo falls back to
+// the plain card token it has always used. Plain fetch — no Stripe SDK here.
+// ⚠️ The throwaway card is minted FRESH per booking, deliberately. A
+// PaymentMethod built from a single-use token (tok_visa) and never attached to
+// a Customer is CONSUMED once a PaymentIntent draws on it — Stripe then refuses
+// to issue an SPT against it ("The payment method is in a consumed or deleted
+// state"). Caching one per process therefore broke every booking after the
+// first. One extra test-mode API call per booking is the price of a wallet that
+// works twice.
+const mintSharedPaymentToken = async (amountMinor, currency) => {
+    if (!STRIPE_AGENT_KEY || !SELLER_PROFILE)
+        return null;
+    // A live key here means a booking charges a REAL card for the full resort
+    // price (€1,280–2,900) the moment someone clicks pay in the card — with no
+    // confirmation step anywhere. Refuse unless that is explicitly what you want.
+    if (STRIPE_AGENT_SECRET_KEY_IS_LIVE && !WALLET_LIVE_OK) {
+        throw new Error('refusing to mint with a LIVE Stripe key — a booking would charge a real card for the full resort price. Set SINOCARE_ALLOW_LIVE_WALLET=1 if that is genuinely intended.');
+    }
+    const post = async (path, body, preview = false) => {
+        const res = await fetch(`https://api.stripe.com/v1/${path}`, {
+            method: 'POST',
+            headers: {
+                authorization: `Bearer ${STRIPE_AGENT_KEY}`,
+                'content-type': 'application/x-www-form-urlencoded',
+                ...(preview ? { 'stripe-version': '2026-04-22.preview' } : {}),
+            },
+            body: new URLSearchParams(body),
+        });
+        const json = (await res.json());
+        if (!res.ok)
+            throw new Error(`stripe ${path} -> ${res.status}: ${json.error?.message ?? ''}`);
+        return json;
+    };
+    // The card the token draws on. A real wallet uses the customer's saved card;
+    // in test mode a fresh throwaway one stands in for every booking (see above).
+    const pm = AGENT_PM ??
+        String((await post('payment_methods', { type: 'card', 'card[token]': 'tok_visa' })).id);
+    const spt = await post('shared_payment/issued_tokens', {
+        payment_method: pm,
+        'seller_details[network_business_profile]': SELLER_PROFILE,
+        'usage_limits[currency]': currency.toLowerCase(),
+        'usage_limits[max_amount]': String(amountMinor),
+        'usage_limits[expires_at]': String(Math.floor(Date.now() / 1000) + 900),
+    }, true).catch((err) => {
+        // A PINNED card hits the same one-shot wall, and there we can't just mint a
+        // new one — say so instead of surfacing Stripe's bare message.
+        if (AGENT_PM && /consumed or deleted/i.test(String(err))) {
+            throw new Error(`STRIPE_AGENT_PAYMENT_METHOD (${AGENT_PM}) is spent — a payment method built from a single-use token can back exactly one charge. Unset it and the demo mints a fresh throwaway card per booking, or pin one attached to a Customer.`);
+        }
+        throw err;
+    });
+    return String(spt.id);
+};
+// Sinocare backend (public — no buyer token; the merchant key lives there).
+const backend = async (path, init = {}) => {
+    const res = await fetch(`${SINOCARE}${path}`, {
+        ...init,
+        headers: { 'content-type': 'application/json', ...(init.headers ?? {}) },
+    });
+    if (!res.ok) {
+        throw new Error(`sinocare-backend ${path} -> ${res.status}: ${await res.text().catch(() => '')}`);
+    }
+    return (await res.json());
+};
+// --- x402 (stablecoin) payment --------------------------------------------
+// x402 settles USDC. The amount is now MERCHANT-QUOTED: sinocare-backend opens a
+// merchant-quoted x402 session via the SDK and sets the USDC price (a small
+// fixed test charge on testnet). The buyer just signs + pays the session — it
+// never computes or passes the amount.
+// The buyer's x402 signer, resolved once and cached:
+//   • X402_SIGNER=cdp        → a Coinbase CDP Server Wallet (zero raw key; for
+//                              mainnet — needs CDP_API_KEY_ID/_SECRET/_WALLET_SECRET)
+//   • X402_PAYER_PRIVATE_KEY → a local key (testnet/mainnet)
+//   • neither                → null (signX402 falls back to a throwaway key,
+//                              which only settles under a STUB facilitator)
+// Returning the Eip712Signer (address + signTypedData) lets both the balance
+// pre-flight and the wallet tool read .address regardless of signer kind.
+const useCdpSigner = process.env.X402_SIGNER === 'cdp';
+let buyerSignerPromise;
+const buyerSigner = () => {
+    buyerSignerPromise ??= (async () => {
+        if (useCdpSigner)
+            return cdpAccountSigner();
+        const k = process.env.X402_PAYER_PRIVATE_KEY;
+        return k ? signerFromPrivateKey(k) : null;
+    })();
+    return buyerSignerPromise;
+};
+const fmtUsdc = (baseUnits) => `${(Number(baseUnits) / 1e6).toFixed(2)} USDC`;
+// Answer an x402 402 challenge: sign an EIP-3009 transferWithAuthorization (via
+// the buyer x402 SDK) → base64 X-PAYMENT header. With a REAL facilitator (Base
+// Sepolia or mainnet) the signer must hold USDC on that chain — configure a CDP
+// wallet or X402_PAYER_PRIVATE_KEY; without either a throwaway key signs, which
+// only settles under a STUB facilitator.
+const signX402 = async (r) => {
+    const signer = (await buyerSigner()) ?? (await signerFromPrivateKey(generatePrivateKey()));
+    return encodeXPaymentHeader(await signX402Payment({ signer, requirements: r }));
+};
+// --- RLUSD (XRP Ledger) x402 payment --------------------------------------
+// The buyer's XRPL wallet, from XRPL_BUYER_SEED (an `sEd…` seed → Ed25519). A
+// real buyer holds this in a wallet; the demo derives it from env. Null when
+// unset — the RLUSD tool then tells the user to configure it. Unlike USDC there
+// is no throwaway fallback: settling RLUSD needs a funded, trust-lined account.
+const XRPL_SEED = process.env.XRPL_BUYER_SEED;
+const XRPL_RPC = process.env.XRPL_TESTNET_WSS ?? 'wss://s.altnet.rippletest.net:51233';
+let xrplWalletCache = null;
+const xrplBuyer = () => {
+    if (xrplWalletCache)
+        return xrplWalletCache;
+    if (!XRPL_SEED)
+        return null;
+    xrplWalletCache = XrplWallet.fromSeed(XRPL_SEED);
+    return xrplWalletCache;
+};
+// USDC-over-Solana buyer: SOLANA_BUYER_SECRET is a devnet Solana secret key (a
+// solana-keygen JSON array or a base58 string) holding devnet USDC. Cached as a
+// promise (base58 decode is async). SOLANA_RPC fetches balances + a blockhash.
+const SOLANA_RPC = process.env.SOLANA_RPC_URL ?? 'https://api.devnet.solana.com';
+let solanaSecretPromise;
+const solanaBuyerSecret = () => {
+    solanaSecretPromise ??= (async () => {
+        const s = process.env.SOLANA_BUYER_SECRET;
+        if (!s)
+            return null;
+        try {
+            return await secretKeyFromString(s);
+        }
+        catch {
+            return null;
+        }
+    })();
+    return solanaSecretPromise;
+};
+// The buyer's USDC balance (base units) across its token accounts for a mint, via
+// a raw Solana JSON-RPC call (no SPL SDK). null on any RPC error → skip pre-flight.
+const solanaUsdcBalance = async (owner, mint) => {
+    try {
+        const res = await fetch(SOLANA_RPC, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'getTokenAccountsByOwner',
+                params: [owner, { mint }, { encoding: 'jsonParsed' }],
+            }),
+        });
+        // biome-ignore lint/suspicious/noExplicitAny: raw JSON-RPC shape
+        const j = (await res.json());
+        const accounts = j?.result?.value ?? [];
+        let total = 0;
+        for (const a of accounts) {
+            total += Number(a?.account?.data?.parsed?.info?.tokenAmount?.amount ?? 0);
+        }
+        return total;
+    }
+    catch {
+        return null;
+    }
+};
+// Skyfire KYAPay — the BUYER mints a Skyfire-SIGNED PAY token (Skyfire's key signs
+// it; unlike the crypto rails the buyer can't self-sign) and presents it to the
+// MERCHANT backend, which charges it via the merchant SDK. SKYFIRE_BUYER_API_KEY
+// mints (buyer agent key from the Skyfire dashboard); SKYFIRE_SELLER_SERVICE_ID is
+// the seller service the payment authorizes. The agentbank key that verifies +
+// charges is the MERCHANT backend's, not the demo's.
+const SKYFIRE_API = process.env.SKYFIRE_API_URL ?? 'https://api.skyfire.xyz';
+const SKYFIRE_BUYER_API_KEY = process.env.SKYFIRE_BUYER_API_KEY;
+const SKYFIRE_SELLER_SERVICE_ID = process.env.SKYFIRE_SELLER_SERVICE_ID;
+// A small fixed test charge (USD quote → settles USDC). Pin with SKYFIRE_TEST_AMOUNT.
+// 0.001 keeps each test charge tiny so a small Skyfire balance covers many runs.
+const SKYFIRE_TEST_AMOUNT = process.env.SKYFIRE_TEST_AMOUNT ?? '0.001';
+// --- MPP · Tempo — on-chain TIP-20 settlement (Tempo payments chain, testnet) ---
+// MPP's `tempo` method: agentbank answers with a 402 whose signed challenge carries
+// the on-chain terms; the buyer wallet (TEMPO_BUYER_PRIVATE_KEY, funded pathUSD via
+// the Tempo faucet) pays with transferWithMemo; agentbank verifies the transfer
+// on-chain by tx hash. The buyer side (pay + credential) is the SDK
+// @curless/agentbank-protocols/tempo — the demo only holds config. A tiny fixed
+// amount so a small balance covers many runs.
+const TEMPO_RPC = process.env.TEMPO_RPC_URL ?? 'https://rpc.moderato.tempo.xyz';
+const TEMPO_BUYER_PRIVATE_KEY = process.env.TEMPO_BUYER_PRIVATE_KEY;
+const MPP_TEMPO_TEST_AMOUNT = Number(process.env.MPP_TEMPO_TEST_AMOUNT ?? 10000); // 0.01 pathUSD (6dp)
+// Mint a Skyfire PAY token (Skyfire ES256-signs it) authorizing `amountUsd` to our
+// seller service — returned as a JWT the buyer presents in the x-kyapay-token header.
+const mintSkyfirePayToken = async (amountUsd) => {
+    if (!SKYFIRE_BUYER_API_KEY)
+        throw new Error('set SKYFIRE_BUYER_API_KEY');
+    if (!SKYFIRE_SELLER_SERVICE_ID)
+        throw new Error('set SKYFIRE_SELLER_SERVICE_ID');
+    const expiresAt = Math.floor(Date.now() / 1000) + 300;
+    const res = await fetch(`${SKYFIRE_API}/api/v1/tokens`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json', 'skyfire-api-key': SKYFIRE_BUYER_API_KEY },
+        body: JSON.stringify({
+            type: 'pay',
+            buyerTag: `sinocare-${Date.now()}`,
+            tokenAmount: amountUsd,
+            sellerServiceId: SKYFIRE_SELLER_SERVICE_ID,
+            expiresAt,
+        }),
+    });
+    if (!res.ok) {
+        throw new Error(`skyfire mint -> ${res.status}: ${(await res.text()).slice(0, 200)}`);
+    }
+    const { token } = (await res.json());
+    if (!token)
+        throw new Error('skyfire mint returned no token');
+    return token;
+};
+// Run a callback with a connected XRPL client, always disconnecting after — so a
+// booking opens ONE connection for the balance pre-flight AND the signing autofill
+// instead of one each.
+const withXrplClient = async (fn) => {
+    const client = new XrplClient(XRPL_RPC);
+    await client.connect();
+    try {
+        return await fn(client);
+    }
+    finally {
+        await client.disconnect().catch(() => undefined);
+    }
+};
+// Read the buyer's balance of an XRPL IOU (RLUSD) via account_lines — the trust
+// line to the issuer for that currency. Returns the decimal string balance, '0'
+// if no trust line / no funds. Uses the caller's connected client.
+const rlusdBalance = async (client, owner, currencyHex, issuer) => {
+    try {
+        const res = await client.request({ command: 'account_lines', account: owner, peer: issuer });
+        const line = res.result.lines.find((l) => l.currency === currencyHex && l.account === issuer);
+        return line?.balance ?? '0';
+    }
+    catch {
+        return '0';
+    }
+};
+// Answer an XRPL x402 402 challenge: sign a standard Payment (Ed25519, invoice
+// bound as a Memo) via the buyer /xrpl SDK → base64 X-PAYMENT, using the caller's
+// connected client for autofill. The wallet must hold RLUSD + a little test XRP.
+const signXrpl = async (client, r, wallet) => encodeXrplXPaymentHeader(await signXrplPayment({ requirements: r, wallet, client }));
+// Persist the standing authorization across restarts. It's a delegation the user
+// signs ONCE (authorize_agent_budget); keeping it only in memory meant a process
+// restart silently dropped the cap, letting an over-budget booking slip through.
+// The mandate is a self-contained signed JWS, so persisting + re-presenting it
+// stays cryptographically valid (we store it, we don't re-sign). Keyed to the
+// agent token so a different buyer can't inherit a stale grant; an expired grant
+// is dropped on load. Override the path with SINOCARE_DEMO_BUDGET_FILE.
+const BUDGET_FILE = process.env.SINOCARE_DEMO_BUDGET_FILE ?? join(homedir(), '.agentbank-sinocare-budget.json');
+const tokenFp = TOKEN ? createHash('sha256').update(TOKEN).digest('hex').slice(0, 16) : '';
+const saveBudget = (b) => {
+    try {
+        // mode 0o600: the file holds a signed IntentMandate (a bearer authorization);
+        // keep it owner-only, not world-readable, even in a demo home dir.
+        if (b)
+            writeFileSync(BUDGET_FILE, JSON.stringify({ tokenFp, budget: b }), {
+                encoding: 'utf8',
+                mode: 0o600,
+            });
+        else
+            rmSync(BUDGET_FILE, { force: true });
+    }
+    catch {
+        /* best-effort: a demo persistence hiccup must never break booking */
+    }
+};
+const loadBudget = () => {
+    try {
+        const saved = JSON.parse(readFileSync(BUDGET_FILE, 'utf8'));
+        const b = saved.budget;
+        // Ignore a grant signed for a different token, or one that has expired.
+        if (saved.tokenFp !== tokenFp || !b?.expiresAt || Date.parse(b.expiresAt) < Date.now()) {
+            rmSync(BUDGET_FILE, { force: true });
+            return null;
+        }
+        return b;
+    }
+    catch {
+        return null;
+    }
+};
+let agentBudget = loadBudget();
+let lastCheckout = null;
+const completedBookings = new Map();
+// Persist the card's checkout state (last pick + booking receipts) across restarts
+// and conversations, so returning to a paid resort's card shows its receipt
+// instead of resetting to the picker — and so a fresh "book it again" starts
+// clean. Keyed to the agent token so a different buyer starts empty. Override the
+// path with SINOCARE_DEMO_STATE_FILE.
+const STATE_FILE = process.env.SINOCARE_DEMO_STATE_FILE ?? join(homedir(), '.agentbank-sinocare-checkout.json');
+const saveCheckoutState = () => {
+    // No buyer token → no stable identity to key on. Persisting under an empty
+    // tokenFp would pool every anonymous buyer into one shared file (and let one
+    // clobber another), so keep this session's state in memory only.
+    if (!tokenFp)
+        return;
+    try {
+        // Read-merge-write: a sibling process (another conversation for the SAME
+        // buyer) may have booked between our startup snapshot and now. Union its
+        // bookings with ours — ours wins ties (we just acted) — so our stale
+        // snapshot never clobbers a booking another conversation recorded.
+        const merged = new Map(completedBookings);
+        try {
+            const disk = JSON.parse(readFileSync(STATE_FILE, 'utf8'));
+            if (disk.tokenFp === tokenFp) {
+                for (const [k, v] of disk.bookings ?? [])
+                    if (!merged.has(k))
+                        merged.set(k, v);
+            }
+        }
+        catch {
+            /* no readable prior file — just write ours */
+        }
+        // Fold the union back into memory so this long-lived process also sees a
+        // sibling conversation's bookings on its next rehydrate (no restart needed).
+        for (const [k, v] of merged)
+            if (!completedBookings.has(k))
+                completedBookings.set(k, v);
+        // Atomic replace: write a temp then rename, so a concurrent reader never
+        // observes a half-written file.
+        const tmp = `${STATE_FILE}.${process.pid}.tmp`;
+        writeFileSync(tmp, JSON.stringify({ tokenFp, lastCheckout, bookings: [...merged] }), {
+            encoding: 'utf8',
+            mode: 0o600,
+        });
+        renameSync(tmp, STATE_FILE);
+    }
+    catch {
+        /* best-effort: a demo persistence hiccup must never break the card */
+    }
+};
+if (tokenFp) {
+    try {
+        const saved = JSON.parse(readFileSync(STATE_FILE, 'utf8'));
+        // Ignore state saved under a different buyer token.
+        if (saved.tokenFp === tokenFp) {
+            // ⚠️ `bookings` ONLY. `lastCheckout` is deliberately NOT restored.
+            //
+            // It exists for one case: a card self-healing with no arguments, where
+            // the server replays the last pick so the widget fills instead of
+            // hanging. Restored from disk it does that to a card belonging to a
+            // DIFFERENT resort — restart the app, ask for a new hotel, and the card
+            // renders the previous booking's receipt, which reads as having booked
+            // something you did not.
+            //
+            // `bookings` is safe to restore because it is keyed by sku: it is only
+            // ever consulted for a resort someone actually asked about.
+            for (const [k, v] of saved.bookings ?? [])
+                completedBookings.set(k, v);
+        }
+    }
+    catch {
+        /* no persisted state yet — start empty */
+    }
+}
+// Record a completed booking (only when it actually settled) and return the tool
+// result — so every buy_sinocare_product_* success is remembered for rehydration
+// in ONE place. Pulls the human fields off the result value the tool already
+// built (total shape differs by rail: total / paidUsdc / paidRlusd / priceEur).
+const finishBooking = (sku, value) => {
+    if (sku && value.booked) {
+        // Record the sale on the Shopify side, if the catalog is Shopify-backed.
+        // Fire-and-forget: the booking already settled through agentbank, so a
+        // writeback failure must never affect the tool result. The backend no-ops
+        // when Shopify isn't configured, so this is safe to call unconditionally.
+        void backend('/shopify-order', {
+            method: 'POST',
+            body: JSON.stringify({
+                sku,
+                quantity: value.quantity,
+                protocol: value.protocol,
+                // Canonical writeback idempotency key: the settled order/PI id (also the
+                // searchable Shopify tag), falling back to the checkout session id so
+                // EVERY protocol dedups. A missing key means no dedup, and a hung-call
+                // re-fire would then create a duplicate Shopify order.
+                orderId: value.orderId ?? value.sessionId ?? value.paymentIntentId,
+                // So the Shopify order lands under a customer, not anonymously.
+                ...(BUYER ? { buyer: BUYER } : {}),
+            }),
+        }).catch(() => { });
+        completedBookings.set(sku, {
+            sku,
+            name: String(value.resort ?? ''),
+            protocol: value.protocol,
+            total: (value.total ?? value.paidUsdc ?? value.paidRlusd ?? value.priceEur),
+            status: value.status,
+            orderId: value.orderId,
+            txHash: value.txHash,
+            explorer: value.explorer,
+            message: value.message,
+        });
+        // Mark this pick as paid so a later rehydrate resolves to the receipt — not
+        // by the presence of a booking record (which we now keep across re-opens),
+        // but by whether THIS checkout was actually completed.
+        if (lastCheckout?.sku === sku)
+            lastCheckout.booked = true;
+        saveCheckoutState();
+    }
+    return text(value);
+};
+// The 'booked' card view: a receipt shown when a rehydrated checkout resolves to
+// an already-booked resort. Carries the pick fields too so the card's "再订一次"
+// button can drop straight back into the picker without another round-trip.
+const bookedView = (pick, r) => ({
+    view: 'booked',
+    sku: pick.sku,
+    name: pick.name,
+    priceEur: pick.priceEur,
+    quantity: pick.quantity,
+    protocol: r.protocol,
+    total: r.total ?? pick.priceEur,
+    status: r.status,
+    orderId: r.orderId,
+    txHash: r.txHash,
+    explorer: r.explorer,
+    message: r.message,
+});
+// MCP App card (a single ui:// resource, TWO views chosen by structuredContent.
+// view). start_sinocare_checkout → the payment-method picker; list_my_orders → the
+// buyer's bookings (each refundable). Both advertise it on BOTH their tool
+// definition AND their result via _meta.ui.resourceUri (mirrors the merchant card
+// — the host needs it on the tool to know it renders a widget); each returns its
+// data as structuredContent, and the card calls the book_* / request_refund /
+// create_sinocare_payment_link tools back.
+// ⚠️ BUMP THIS WHENEVER widget/ CHANGES. The host caches the card's HTML by
+// this URI, so shipping new widget code under the old one leaves every
+// existing conversation rendering the previous build — the server returns
+// corrected data and the old JS draws the old picture. Three widget changes
+// went out today without a bump, and the receipt/picker fix appeared to have
+// no effect at all because of it.
+const CHECKOUT_URI = 'ui://sinocare/card-v23.html';
+const CARD_MIME = 'text/html;profile=mcp-app';
+const CHECKOUT_UI_META = { ui: { resourceUri: CHECKOUT_URI }, 'ui/resourceUri': CHECKOUT_URI };
+const TOOLS = [
+    {
+        name: 'list_sinocare_products',
+        description: 'Browse Sinocare resorts worldwide (Alps & Japan ski; Mediterranean, Indian Ocean, Caribbean & Americas sun) — shows the per-person/week price. Optional country (ISO-2, e.g. FR/IT/JP/MV/MQ/MX) or kind (ski|sun) filter.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                country: { type: 'string', description: 'ISO-2, e.g. FR / IT / JP / MV / MU / MQ / MX' },
+                kind: { type: 'string', enum: ['ski', 'sun'] },
+            },
+        },
+    },
+    {
+        name: 'get_sinocare_product',
+        description: 'Get one Sinocare resort by its sku (from list_sinocare_products).',
+        inputSchema: {
+            type: 'object',
+            required: ['sku'],
+            properties: { sku: { type: 'string' } },
+        },
+    },
+    {
+        name: 'start_sinocare_checkout',
+        description: "THE DEFAULT WAY TO BOOK. Open a visual checkout card for a Sinocare resort so the user PICKS a payment method by clicking (instead of typing) — Card (ACP) / UCP / USDC (x402) / RLUSD (XRP Ledger) in-conversation, or a Payment Link hosted page. When the user wants to book, CALL THIS — do not list the payment methods as text and ask which one; the card is where the user chooses and pays. ALWAYS prefer this over buy_sinocare_product_*. YOU MUST identify the resort: pass its `sku` OR a `query` name (e.g. 'Val d'Isère', 'Saint-Moritz') — do NOT call this with no resort (the card can't render without one). If one resort matches, open its card directly rather than asking to confirm.",
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sku: {
+                    type: 'string',
+                    description: "the resort's exact sku (from list_sinocare_products)",
+                },
+                query: {
+                    type: 'string',
+                    description: "the resort NAME (e.g. 'Val d'Isère') — used if you don't have the exact sku; resolved server-side. Pass `sku` OR `query`.",
+                },
+                quantity: { type: 'integer', description: 'number of guests/weeks (default 1)' },
+            },
+        },
+        _meta: CHECKOUT_UI_META,
+    },
+    {
+        name: 'create_sinocare_payment_link',
+        description: "Create a Payment Link for a resort — a PUBLIC hosted checkout page (like a Stripe Payment Link) the user opens in a browser to pay (test-mode card). Returns the URL. Mostly invoked by the checkout card's 'Payment Link' button; the external-link payment path.",
+        inputSchema: {
+            type: 'object',
+            required: ['sku'],
+            properties: {
+                sku: { type: 'string' },
+                quantity: { type: 'integer', description: 'number of guests/weeks (default 1)' },
+            },
+        },
+    },
+    {
+        name: 'curless_wallet_logout',
+        description: 'Sign the buyer out of their Curless wallet and revoke the session, so it cannot be used again. Use when the person asks to sign out, or is done and someone else may use this machine. After this, paying from the wallet needs a fresh sign-in.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'curless_wallet_login_status',
+        description: "Whether the buyer has signed in to the wallet session THIS STOREFRONT holds — the one the in-card 'Curless 买家钱包' method uses. It says nothing about a separately-installed Curless wallet connector, which keeps its own session: for that one, call its own wallet_login. The checkout card polls this by itself — you do not normally need to.",
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'buy_sinocare_product_wallet',
+        description: "Book a Sinocare resort over ACP, paying from the buyer's own Curless wallet: the wallet mints a credential from the card THEY bound, capped by the limits THEY set, scoped to this seller and this amount for 15 minutes. If nobody is signed in, this returns a sign-in link — show it to the person; the card polls on its own and pays once they finish in the browser. Do NOT ask them for a password in the chat. If the wallet refuses because the booking is over their limit, tell the person it is their own limit and offer to raise it — do not retry with another payment method.",
+        inputSchema: {
+            type: 'object',
+            required: ['sku'],
+            properties: {
+                sku: { type: 'string' },
+                quantity: { type: 'integer', description: 'number of guests/weeks (default 1)' },
+            },
+        },
+    },
+    {
+        // ── mode 2: two independent MCP servers, the model carries the credential ──
+        // Nothing here knows the wallet exists. It opens a checkout, states the
+        // amount, and says what to do next; the wallet is a separate connector the
+        // buyer installed, and the MODEL is the only thing that can reach both.
+        // That is not a workaround — MCP servers cannot call each other, so the
+        // handoff is a tool description on each side and a string in between.
+        name: 'start_sinocare_wallet_handoff',
+        description: "Open a Sinocare checkout to be paid by a SEPARATELY-INSTALLED Curless wallet connector (@curless/agentbank-mcp). Returns {sessionId, merchantId, amount, currency}. Next: call that connector's `wallet_pay_credential` with exactly this amount, currency and merchantRef=merchantId, then pass the token it returns to `pay_sinocare_with_token`. Use this only when the buyer HAS the Curless wallet connector installed; if they do not, use buy_sinocare_product_wallet or pay_sinocare_hosted instead. ⚠️ If wallet_pay_credential fails — not signed in, over their own limit, no card bound — STOP and tell the person what it said. Do NOT book this another way: they chose to pay from their own wallet, and settling it with the agent's credential instead spends different money and reports it as theirs.",
+        inputSchema: {
+            type: 'object',
+            required: ['sku'],
+            properties: {
+                sku: { type: 'string' },
+                quantity: { type: 'integer', description: 'number of guests/weeks (default 1)' },
+            },
+        },
+    },
+    {
+        name: 'pay_sinocare_with_token',
+        description: 'Complete a Sinocare checkout opened by start_sinocare_wallet_handoff, using a payment credential minted elsewhere (a Stripe shared payment token, spt_…). Sinocare completes the charge with its own merchant key — it never sees a card. Pass the sessionId from the handoff and the token from the wallet.',
+        inputSchema: {
+            type: 'object',
+            required: ['sessionId', 'merchantId', 'token'],
+            properties: {
+                sessionId: { type: 'string' },
+                merchantId: { type: 'string', description: 'from start_sinocare_wallet_handoff' },
+                token: { type: 'string', description: 'spt_… from the buyer wallet' },
+            },
+        },
+    },
+    {
+        // ── mode 3: hosted approval, the buyer needs nothing installed ──
+        // The shape that works for a person with only a browser. Same idea as a
+        // Stripe Checkout link: we hand over a URL, they see what they are paying
+        // and to whom, and approve it on the wallet's own page.
+        name: 'pay_sinocare_hosted',
+        description: 'Open a Sinocare checkout and return a Curless approval LINK for the buyer to open in their browser. They see the amount and the merchant, sign in if needed, and approve; Curless charges the card they bound. Use this when the buyer has NOTHING installed — no wallet connector, no agent credential. Show them the link; then call get_sinocare_order_status with the sessionId and merchantId to see whether it has been paid. Do not claim it is paid until that says so, and do NOT book it another way while they are still on the page.',
+        inputSchema: {
+            type: 'object',
+            required: ['sku'],
+            properties: {
+                sku: { type: 'string' },
+                quantity: { type: 'integer', description: 'number of guests/weeks (default 1)' },
+            },
+        },
+    },
+    {
+        name: 'get_sinocare_order_status',
+        description: 'Check whether a checkout session has been paid. Use after pay_sinocare_hosted, since the approval happens in the browser and this server is not told when it does. Returns the session status — `completed` means the money moved.',
+        inputSchema: {
+            type: 'object',
+            required: ['sessionId', 'merchantId'],
+            properties: {
+                sessionId: { type: 'string' },
+                merchantId: { type: 'string', description: 'from the tool that opened this checkout' },
+            },
+        },
+    },
+    {
+        name: 'buy_sinocare_product_acp',
+        description: 'Book a Sinocare resort over ACP (Agentic Commerce Protocol) — Sinocare prices the resort and opens a merchant-quoted checkout session; this agent completes it with a delegated card credential, settling on the card rail (test mode). One of THREE ways to pay: ACP (card) / UCP (card) / x402 (USDC). The card rail is an implementation detail, not a separate payment choice. Returns the booked order.',
+        inputSchema: {
+            type: 'object',
+            required: ['sku'],
+            properties: {
+                sku: { type: 'string' },
+                quantity: { type: 'integer', description: 'number of guests/weeks (default 1)' },
+            },
+        },
+    },
+    {
+        name: 'buy_sinocare_product_ucp',
+        description: 'Book a Sinocare resort over UCP (Universal Commerce Protocol, ucp.dev) — Sinocare prices it and opens a UCP checkout session. UCP "supports x402", and x402 is chain-agnostic, so the SAME UCP session settles FOUR ways (pass `pay`): `card` (default) → the agent authorizes with an AP2 PaymentMandate bound to the cart, settled on the card rail (test mode, same as ACP); `usdc` → the gateway freezes an x402 challenge and the agent pays with a signed EIP-3009 X-PAYMENT (USDC on Base/EVM); `usdc-sol` → same, on Solana — the agent partially signs an SPL transfer the facilitator co-signs + submits (USDC on Solana, buyer needs no SOL); `rlusd` → an XRPL x402 challenge, a signed XRPL Payment (Ed25519, no gas), on the XRP Ledger. The three stablecoin ways all settle on-chain over the stablecoin rail — currency + chain just pick the rail. The standing authorization (authorize_agent_budget) is attached on the card path. Returns the booked order.',
+        inputSchema: {
+            type: 'object',
+            required: ['sku'],
+            properties: {
+                sku: { type: 'string' },
+                quantity: { type: 'integer', description: 'number of guests/weeks (default 1)' },
+                pay: {
+                    type: 'string',
+                    enum: ['card', 'usdc', 'usdc-sol', 'rlusd'],
+                    description: 'payment method for this UCP session: card (default), usdc (x402 · USDC on Base/EVM), usdc-sol (x402 · USDC on Solana), or rlusd (x402 · RLUSD on the XRP Ledger)',
+                },
+            },
+        },
+    },
+    {
+        name: 'authorize_agent_budget',
+        description: 'Delegate autonomous Sinocare booking to this agent via an AP2 IntentMandate: you sign a STANDING authorization (a spend cap per booking + a time window) ONCE, and the agent can then complete UCP bookings within it without confirming each purchase. Bookings over the cap (or after it expires) are rejected by the gateway. This is the AP2 "user authorizes intent, agent acts within it" delegation.',
+        inputSchema: {
+            type: 'object',
+            required: ['maxAmountEur'],
+            properties: {
+                maxAmountEur: {
+                    type: 'number',
+                    description: 'spend cap PER booking, in EUR (e.g. 2000)',
+                },
+                hours: {
+                    type: 'integer',
+                    description: 'how long the authorization lasts, in hours (default 24)',
+                },
+            },
+        },
+    },
+    {
+        name: 'agent_budget_status',
+        description: 'Show the current standing AP2 booking authorization (spend cap + expiry), or that none is set.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'revoke_agent_budget',
+        description: 'Revoke the standing AP2 booking authorization — the agent must get a fresh one (authorize_agent_budget) to book autonomously again.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'buy_sinocare_product_x402',
+        description: 'Book a Sinocare resort and pay in USDC over x402. `chain` picks the USDC chain: `base` (default) → EVM, a signed EIP-3009 authorization; `solana` → an SVM transfer the buyer partially signs and the facilitator co-signs (feePayer) + submits (buyer needs no SOL). The merchant receives USDC at its address on that chain. Returns the booking + the USDC amount paid (+ the Solana tx on the solana path).',
+        inputSchema: {
+            type: 'object',
+            required: ['sku'],
+            properties: {
+                sku: { type: 'string' },
+                quantity: { type: 'integer', description: 'number of guests/weeks (default 1)' },
+                chain: {
+                    type: 'string',
+                    enum: ['base', 'solana'],
+                    description: 'USDC chain: base (default, EVM) or solana',
+                },
+            },
+        },
+    },
+    {
+        name: 'x402_buyer_wallet',
+        description: 'Show the wallet that pays for x402 (USDC) bookings — its address and USDC balance on Base Sepolia (testnet) + Base (mainnet), and where to top it up. Use this to check funds before booking with USDC.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'buy_sinocare_product_rlusd',
+        description: "Book a Sinocare resort and pay in RLUSD (Ripple USD) over x402 on the XRP Ledger. Sinocare opens a merchant-quoted RLUSD session; this agent signs a standard XRPL Payment (Ed25519, no gas — the buyer pays the tiny XRPL fee) and Curless's self-hosted facilitator submits it on-ledger. Same x402 protocol as the USDC tool, different chain. Returns the booking + the RLUSD amount paid + the XRPL tx.",
+        inputSchema: {
+            type: 'object',
+            required: ['sku'],
+            properties: {
+                sku: { type: 'string' },
+                quantity: { type: 'integer', description: 'number of guests/weeks (default 1)' },
+            },
+        },
+    },
+    {
+        name: 'buy_sinocare_product_skyfire',
+        description: "Book a Sinocare resort over Skyfire KYAPay (agent-native JWT payments). The buyer mints a Skyfire-SIGNED PAY token (via Skyfire, authorizing a small USDC charge to Sinocare — unlike the crypto rails the buyer can't self-sign, Skyfire signs it) and presents it to the Sinocare merchant backend, which charges it via the merchant SDK; agentbank verifies it against Skyfire's live JWKS — proving the agent's identity (Know Your Agent) AND the payment authorization — and records the USDC payment intent. PRODUCTION Skyfire (real token, real verify). Needs SKYFIRE_BUYER_API_KEY + SKYFIRE_SELLER_SERVICE_ID (to mint). Returns the verification + the recorded payment intent (agentbank verifies + records the authorization; it does not auto-capture).",
+        inputSchema: {
+            type: 'object',
+            required: ['sku'],
+            properties: {
+                sku: { type: 'string' },
+                quantity: { type: 'integer', description: 'number of guests/weeks (default 1)' },
+            },
+        },
+    },
+    {
+        name: 'buy_sinocare_product_mpp',
+        description: "Book a Sinocare resort over MPP (Machine Payments Protocol) settled on the Tempo payments chain. agentbank answers the unpaid request with an HTTP-402 Payment challenge whose SIGNED terms carry the on-chain payment (TIP-20 pathUSD token, merchant recipient, memo=challenge binding); the buyer's Tempo wallet pays it with transferWithMemo; the credential proves it by tx HASH and agentbank VERIFIES the on-chain transfer read-only, then captures the payment intent. Real Tempo testnet, on-chain stablecoin — no card, no gateway signing. Needs AGENTBANK_AGENT_TOKEN + TEMPO_BUYER_PRIVATE_KEY (a funded Tempo testnet key).",
+        inputSchema: {
+            type: 'object',
+            required: ['sku'],
+            properties: {
+                sku: { type: 'string' },
+                quantity: { type: 'integer', description: 'number of guests/weeks (default 1)' },
+            },
+        },
+    },
+    {
+        name: 'xrpl_buyer_wallet',
+        description: 'Show the XRPL wallet that pays for RLUSD bookings — its classic r-address and RLUSD trust-line balance on the XRP Ledger testnet. Use this to check funds before booking with RLUSD.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'list_my_orders',
+        description: 'List my Sinocare bookings (orders) — newest first, with id, resort, amount, and status. Renders an interactive card: each settled booking has a 申请退款 (request refund) button. Use the order id with request_refund to ask for a refund.',
+        inputSchema: { type: 'object', properties: {} },
+        _meta: CHECKOUT_UI_META,
+    },
+    {
+        name: 'request_refund',
+        description: 'Request a refund on one of my bookings. Pass the order id (ord_…) from list_my_orders and an optional reason. The merchant (Sinocare) reviews and approves/rejects it.',
+        inputSchema: {
+            type: 'object',
+            required: ['orderId'],
+            properties: {
+                orderId: { type: 'string', description: 'order id from list_my_orders (ord_…)' },
+                reason: { type: 'string' },
+            },
+        },
+    },
+];
+const text = (value) => ({
+    content: [{ type: 'text', text: JSON.stringify(value, null, 2) }],
+});
+// Server instructions — hosts (Claude Desktop) inject these into the model's
+// context. The point: when the user wants to book, OPEN THE CARD, don't retype
+// the payment menu as prose. Left to its own devices the model reads the four
+// book_* tools and helpfully lists ACP / UCP / x402 / RLUSD as a text bullet
+// list and asks — but the whole UX is the visual card, where the user clicks a
+// method and pays in place. So make the card the default and the text list a
+// non-UI fallback only.
+const INSTRUCTIONS = [
+    'Sinocare storefront (buyer side).',
+    'When the user wants to book a resort — any phrasing like "book …", "预订…", "reserve …" — call start_sinocare_checkout (pass the resort `sku`, or a `query` name such as "Saint-Moritz" / "Val d\'Isère") to open the visual checkout card. The user picks a payment method and pays by clicking IN THE CARD.',
+    'Do NOT enumerate the payment methods (ACP / UCP / x402 / RLUSD / Payment Link) as text and ask which one — that is what the card is for. Only fall back to describing options in prose if the checkout card genuinely cannot be shown (a non-UI host).',
+    'If the resort is ambiguous or unknown, resolve it first with list_sinocare_products, then open the checkout card for the chosen resort. If exactly one resort matches, open its card directly rather than asking to confirm.',
+    'Call the buy_sinocare_product_* tools directly only when the card is unavailable or the user explicitly asked for a specific rail in a plain-text flow.',
+].join(' ');
+const server = new Server({ name: 'sinocare', version: '0.5.0' }, { capabilities: { tools: {}, resources: {} }, instructions: INSTRUCTIONS });
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+    resources: [{ uri: CHECKOUT_URI, name: 'Sinocare checkout', mimeType: CARD_MIME }],
+}));
+server.setRequestHandler(ReadResourceRequestSchema, async (req) => {
+    if (req.params.uri !== CHECKOUT_URI)
+        throw new Error(`unknown resource: ${req.params.uri}`);
+    return { contents: [{ uri: CHECKOUT_URI, mimeType: CARD_MIME, text: CHECKOUT_CARD_HTML }] };
+});
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const args = (req.params.arguments ?? {});
+    try {
+        if (req.params.name === 'list_sinocare_products') {
+            const country = typeof args.country === 'string' ? args.country.toUpperCase() : undefined;
+            const kind = typeof args.kind === 'string' ? `?kind=${encodeURIComponent(args.kind)}` : '';
+            const { items } = await backend(`/catalog${kind}`);
+            const resorts = country ? items.filter((r) => r.country === country) : items;
+            return text({ currency: 'EUR', count: resorts.length, resorts });
+        }
+        if (req.params.name === 'get_sinocare_product') {
+            const sku = String(args.sku ?? '');
+            const resort = await backend(`/catalog/${encodeURIComponent(sku)}`);
+            return text(resort);
+        }
+        // Visual checkout: return the MCP App card (payment picker) + the resort as
+        // structuredContent. The card's buttons call the book_* /
+        // create_sinocare_payment_link tools; the card renders their results.
+        if (req.params.name === 'start_sinocare_checkout') {
+            // Accept a `sku` (exact) OR a `query`/`resort`/`name` (e.g. "Val d'Isère")
+            // so the agent doesn't need the exact sku to open the card.
+            const idOrName = String(args.sku ?? args.query ?? args.resort ?? args.name ?? '').trim();
+            const quantity = Math.max(Number(args.quantity) || 1, 1);
+            // The card sets __rehydrate when it re-invokes to fill itself (reload /
+            // self-heal), never on a fresh agent-initiated checkout. Only on rehydrate
+            // do we show a completed booking's receipt instead of the picker — so an
+            // explicit "book X again" from the agent still opens the picker.
+            const rehydrate = args.__rehydrate === true || args.__rehydrate === 1 || args.__rehydrate === '1';
+            // No resort given = the card self-healing (empty-arg re-invoke) — replay the
+            // last pick so the widget fills in instead of hanging on "Loading…". If that
+            // last checkout has since been booked, show its receipt on rehydrate.
+            if (!idOrName) {
+                if (rehydrate && lastCheckout && lastCheckout.booked) {
+                    const receipt = completedBookings.get(lastCheckout.sku);
+                    if (receipt) {
+                        return {
+                            content: [{ type: 'text', text: `Booked ${lastCheckout.name}.` }],
+                            structuredContent: bookedView(lastCheckout, receipt),
+                            _meta: CHECKOUT_UI_META,
+                        };
+                    }
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: lastCheckout
+                                ? `Checkout for ${lastCheckout.name}.`
+                                : 'Pick a resort first (list_sinocare_products), then open its checkout.',
+                        },
+                    ],
+                    structuredContent: lastCheckout ?? {
+                        view: 'pick',
+                        sku: '',
+                        name: '',
+                        priceEur: '',
+                        quantity: 1,
+                    },
+                    _meta: CHECKOUT_UI_META,
+                };
+            }
+            // Resolve: try exact sku first, then a name search over the catalog.
+            let resort = null;
+            try {
+                resort = await backend(`/catalog/${encodeURIComponent(idOrName)}`);
+            }
+            catch {
+                const { items } = await backend('/catalog');
+                const q = idOrName.toLowerCase();
+                resort =
+                    items.find((r) => r.sku.toLowerCase() === q) ??
+                        items.find((r) => r.name.toLowerCase() === q) ??
+                        items.find((r) => r.name.toLowerCase().includes(q)) ??
+                        null;
+            }
+            if (!resort) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `找不到度假村 "${idOrName}" — 用 list_sinocare_products 看可选项,或传它的 sku。`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const priceEur = resort.priceDisplay ?? `€${((resort.price ?? 0) / 100).toLocaleString('en-IE')}`;
+            // Rehydrating an already-BOOKED resort's card → show its receipt, not the
+            // picker (fixes: pay, leave the conversation, come back, and the card had
+            // reset to the payment selection). The card self-heals by re-invoking with
+            // its ORIGINAL args (the sku) + __rehydrate. EXCEPTION: a deliberate "book
+            // it again" is a fresh (non-rehydrate) open that leaves THIS sku's pick
+            // unbooked; its immediate self-heal must resolve to the picker, so suppress
+            // the receipt only while this sku is the one being freshly re-opened. Past
+            // receipts are kept intact (never deleted), so #6's cross-conversation
+            // records — and OTHER booked cards in the same conversation — still
+            // rehydrate to their receipts.
+            // Is THIS checkout paid? Not "has this resort ever been bought".
+            //
+            // The receipt used to be looked up by sku, which treats a resort as a
+            // purchase. It is not: opening a checkout for somewhere you booked last
+            // week is a NEW order. With 42 of 44 resorts recorded, that lookup made
+            // almost every card render as an already-paid receipt the moment it
+            // self-healed — no payment involved — and hid the payment picker behind
+            // a booking that had happened days ago.
+            //
+            // So the question is answered by the checkout in hand: the pick we just
+            // had open, for this same resort, that was actually paid. A fresh open
+            // replaces it with an unpaid one (below), which is what makes "book it
+            // again" resolve to the picker.
+            const rehydratedReceipt = rehydrate && lastCheckout?.sku === resort.sku && lastCheckout.booked
+                ? completedBookings.get(resort.sku)
+                : undefined;
+            lastCheckout = {
+                view: 'pick',
+                sku: resort.sku,
+                name: resort.name,
+                priceEur,
+                quantity,
+                imageUrl: resort.imageUrl,
+                externalShopify: resort.source === 'shopify',
+                // Preserve booked only when rehydrating a paid pick; a fresh open is a
+                // new, unpaid order (booked stays falsy → the card shows the picker).
+                booked: rehydratedReceipt ? true : undefined,
+            };
+            saveCheckoutState(); // persist the new lastCheckout across processes
+            const receipt = rehydratedReceipt;
+            if (receipt) {
+                return {
+                    content: [{ type: 'text', text: `Booked ${resort.name} (${priceEur}).` }],
+                    structuredContent: bookedView(lastCheckout, receipt),
+                    _meta: CHECKOUT_UI_META,
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Checkout for ${resort.name} (${priceEur}). Pick a payment method in the card — Card (ACP) / UCP / USDC (x402) / RLUSD (XRP Ledger), or a Payment Link (hosted page).`,
+                    },
+                ],
+                structuredContent: lastCheckout,
+                _meta: CHECKOUT_UI_META,
+            };
+        }
+        if (req.params.name === 'create_sinocare_payment_link') {
+            const sku = String(args.sku ?? '');
+            const quantity = Math.max(Number(args.quantity) || 1, 1);
+            const link = await backend('/checkout-link', {
+                method: 'POST',
+                // Paying from the wallet means the WALLET's owner is the buyer, so
+                // the merchant records that email. Otherwise the order is filed under
+                // SINOCARE_BUYER_EMAIL and never appears in the wallet's own 订单 —
+                // "我的订单" is joined on the email the order was placed with.
+                body: JSON.stringify({
+                    sku,
+                    quantity,
+                    ...(walletBuyer() ?? (BUYER ? { buyer: BUYER } : {})),
+                }),
+            });
+            return text({
+                url: link.url,
+                amountDisplay: link.amountDisplay,
+                name: link.name,
+                message: `Payment page for ${link.name} — open ${link.url} to pay (${link.amountDisplay}).`,
+            });
+        }
+        if (req.params.name === 'curless_wallet_logout') {
+            const who = wallet.current();
+            await wallet.logout();
+            // Drop the pending browser sign-in too, if one is mid-flight — otherwise
+            // "signed out" would be followed by that login completing and silently
+            // signing them back in.
+            pending = null;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            signedOut: true,
+                            was: who?.email ?? null,
+                            message: who ? `已退出 ${who.email}。` : '本来就没有登录。',
+                        }),
+                    },
+                ],
+            };
+        }
+        if (req.params.name === 'curless_wallet_login_status') {
+            const who = wallet.current();
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(who
+                            ? { signedIn: true, email: who.email, mode: who.mode, wallet: 'storefront' }
+                            : {
+                                signedIn: false,
+                                // Three answers, not two. "waiting" is a sign-in in flight,
+                                // "expired" is one that ran out, and neither is "nobody
+                                // started one" — which used to be reported as expired and
+                                // read back to the person as "your code timed out" when
+                                // they had never been given a code.
+                                waiting: Boolean(pending),
+                                expired: !pending && loginEverStarted,
+                                neverStarted: !pending && !loginEverStarted,
+                                // WHICH wallet. This storefront holds its own buyer session
+                                // for the in-card method; a separately-installed Curless
+                                // wallet connector holds a different one, and this tool can
+                                // say nothing about that. Reported as contradicting each
+                                // other otherwise — reasonably, since both were called "the
+                                // wallet".
+                                wallet: 'storefront',
+                                note: 'this is the session THIS storefront holds (the in-card wallet method). A separately-installed Curless wallet connector has its own session — ask that connector, not this tool.',
+                            }),
+                    },
+                ],
+            };
+        }
+        // ACP, twice over: the agent mints the credential from ITS OWN Stripe key
+        // (buy_sinocare_product_acp), or the buyer's Curless wallet mints it from the
+        // card that buyer bound (buy_sinocare_product_wallet). Everything after the
+        // credential — the session, the complete, the writeback — is identical, so
+        // it is one handler: two code paths would drift, and the difference that
+        // matters is only WHERE the token comes from and WHOSE limits applied.
+        if (req.params.name === 'buy_sinocare_product_acp' ||
+            req.params.name === 'buy_sinocare_product_wallet') {
+            const viaWallet = req.params.name === 'buy_sinocare_product_wallet';
+            // Check the signature BEFORE asking Sinocare to price anything. Opening a
+            // checkout session we already know cannot be paid leaves the merchant an
+            // order that will never complete, and shows the person a backend error
+            // when the actual problem is that nobody signed in.
+            if (viaWallet && !wallet.current()) {
+                // Start the browser sign-in HERE, before Sinocare is asked to price
+                // anything: a checkout session opened for someone who cannot pay is an
+                // order the merchant will never see completed.
+                //
+                // JSON, not prose — the card renders `message` and the model reads
+                // `next`. Prose fails the card's JSON.parse and gets shown to the person
+                // verbatim, which is how an instruction meant for the model once ended
+                // up on screen in English.
+                const login = await pendingLogin();
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                needsLogin: true,
+                                loginUrl: login.verificationUriComplete,
+                                userCode: login.userCode,
+                                message: '在浏览器里登录你的 Curless 钱包,登录完这张卡会自己接上。登录后就能用你自己绑的卡付款,并受你自己设的限额约束。',
+                                next: 'show the person the login link; the card polls on its own. Do NOT ask them for an email here — the sign-in happens in their browser.',
+                            }),
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const sku = String(args.sku ?? '');
+            const quantity = Math.max(Number(args.quantity) || 1, 1);
+            // 1. Sinocare prices the resort + opens a merchant-quoted ACP session.
+            const session = await backend('/checkout-acp', {
+                method: 'POST',
+                body: JSON.stringify({ sku, quantity, ...(BUYER ? { buyer: BUYER } : {}) }),
+            });
+            // 2. Ask the buyer's wallet for a credential scoped to THIS booking. The
+            //    session's real total has to come off the session itself — the backend
+            //    only hands back a display string ("€1,920"), and an SPT's cap is an
+            //    integer in minor units. No wallet configured → keep the card token.
+            let token = PAYMENT_TOKEN;
+            if (viaWallet) {
+                // The buyer's wallet decides. It reads the same real total off the ACP
+                // session, checks the limits THAT PERSON set, and mints against the card
+                // THEY bound — so a refusal here is the buyer's own cap, not a payment
+                // failure, and it is reported that way rather than retried around.
+                const { amount, currency } = totalOf(await readCheckoutSession(acp(session.merchantId), session.sessionId));
+                let credential;
+                try {
+                    credential = await wallet.payCredential({
+                        amount,
+                        currency,
+                        merchantRef: session.merchantId,
+                    });
+                }
+                catch (err) {
+                    // The checkout session stays open and unpaid, which is correct — the
+                    // person may raise their limit and pay it. Nothing was charged.
+                    return walletRefusal(err);
+                }
+                token = credential.token;
+                process.stderr.write(`sinocare-demo: wallet minted ${credential.token} for ${amount} ${currency}\n`);
+            }
+            else if (!STRIPE_AGENT_KEY || !SELLER_PROFILE) {
+                // Say so once, out loud: a silent fallback here looks identical to a
+                // successful SPT payment from the outside (the seller mints its own pm_
+                // either way), which is exactly how you end up believing you tested
+                // something you didn't.
+                process.stderr.write('sinocare-demo: paying ACP with the plain card token — set STRIPE_AGENT_SECRET_KEY and AGENTBANK_SELLER_PROFILE to mint a real SPT per booking\n');
+            }
+            else {
+                // Which fetch failed matters, and node's "fetch failed" hides the real
+                // reason in .cause — without both you get a message that says nothing.
+                let step = 'read session';
+                try {
+                    const { amount, currency } = totalOf(await readCheckoutSession(acp(session.merchantId), session.sessionId));
+                    step = 'mint SPT';
+                    const minted = await mintSharedPaymentToken(amount, currency);
+                    if (minted) {
+                        token = minted;
+                        process.stderr.write(`sinocare-demo: minted ${minted} for ${amount} ${currency}\n`);
+                    }
+                }
+                catch (err) {
+                    const e = err;
+                    const why = e.cause?.code ?? e.cause?.message ?? '';
+                    const what = `SPT FAILED at [${step}]: ${e.message}${why ? ` (cause: ${why})` : ''}`;
+                    // Strict by default. Configuring a wallet says you want a credential
+                    // bound to THIS seller, amount and expiry; quietly paying with an
+                    // unscoped card token instead is a downgrade, not graceful
+                    // degradation — and the booking still succeeds, so nobody notices.
+                    if (!WALLET_FALLBACK_OK) {
+                        throw new Error(`${what} — refusing to fall back to an unscoped card token. Set SINOCARE_WALLET_FALLBACK=1 to allow that.`);
+                    }
+                    process.stderr.write(`sinocare-demo: ${what} — falling back to ${PAYMENT_TOKEN}\n`);
+                }
+            }
+            // 3. This buyer agent completes the charge over ACP with that credential.
+            const order = (await completeCheckout(acp(session.merchantId), session.sessionId, token));
+            return finishBooking(sku, {
+                booked: order.status === 'completed',
+                resort: session.name,
+                quantity,
+                total: session.amountDisplay,
+                protocol: 'acp',
+                payer: viaWallet ? 'curless-wallet' : 'agent-key',
+                status: order.status,
+                // An ACP complete can omit order.id; fall back to the (always-present,
+                // stable) checkout session id so the writeback always has a dedup key.
+                orderId: order.order?.id ?? session.sessionId,
+                message: `Booked ${session.name} × ${quantity} — ${session.amountDisplay} charged (${order.status}).`,
+            });
+        }
+        // ── mode 2 · step 1: open a checkout for a wallet this server cannot reach ──
+        if (req.params.name === 'start_sinocare_wallet_handoff') {
+            if (!TOKEN) {
+                return text({ error: 'sinocare-demo: AGENTBANK_AGENT_TOKEN is not set' });
+            }
+            const sku = String(args.sku ?? '');
+            const quantity = Math.max(Number(args.quantity) || 1, 1);
+            const session = await backend('/checkout-acp', {
+                method: 'POST',
+                body: JSON.stringify({ sku, quantity, ...(BUYER ? { buyer: BUYER } : {}) }),
+            });
+            // The authoritative total, off the session — the backend's amountDisplay
+            // is a string for a human ("€1,920") and a credential is capped by an
+            // integer in minor units.
+            const { amount, currency } = totalOf(await readCheckoutSession(acp(session.merchantId), session.sessionId));
+            return text({
+                // This OPENED a checkout; it did not pay for one. Said explicitly
+                // because a result that mentions neither used to render as a receipt.
+                booked: false,
+                awaitingPayment: true,
+                message: '结账已开好。接下来在你自己的 Curless 钱包连接器里铸一张凭据,再回来完成付款。',
+                sessionId: session.sessionId,
+                merchantId: session.merchantId,
+                amount,
+                currency,
+                resort: session.name,
+                total: session.amountDisplay,
+                // Spells out the sign-in step. Without it the model calls
+                // wallet_pay_credential, gets "nobody is signed in", and has to invent
+                // what to do next — which is how a booking the person asked to pay
+                // from their own wallet ends up settled some other way.
+                next: `on the Curless wallet connector: if nobody is signed in, call wallet_login FIRST, show the person the link it returns, and wait until they say they have finished in their browser. Then wallet_pay_credential({ amount: ${amount}, currency: "${currency}", merchantRef: "${session.merchantId}" }), then pay_sinocare_with_token({ sessionId: "${session.sessionId}", merchantId: "${session.merchantId}", token }). If the wallet still refuses, STOP and tell the person what it said — do not pay this another way.`,
+            });
+        }
+        // ── mode 2 · step 2: the merchant completes, with its own key ──
+        if (req.params.name === 'pay_sinocare_with_token') {
+            if (!TOKEN) {
+                return text({ error: 'sinocare-demo: AGENTBANK_AGENT_TOKEN is not set' });
+            }
+            const sessionId = String(args.sessionId ?? '');
+            const token = String(args.token ?? '');
+            const merchantId = String(args.merchantId ?? '');
+            if (!sessionId || !token || !merchantId) {
+                return text({ error: 'pay_sinocare_with_token needs sessionId, merchantId and token' });
+            }
+            // What this checkout was for comes off the checkout, not out of this
+            // process's memory — the confirmation can arrive in a different one.
+            const bought = purchaseOf(await readCheckoutSession(acp(merchantId), sessionId));
+            const order = (await completeCheckout(acp(merchantId), sessionId, token));
+            const booked = order.status === 'completed';
+            // Same exit as the other ten booking paths. Returning a bare result here
+            // is what let someone pay the same holiday three times: the card had no
+            // idea it had been bought, so it rehydrated to the picker.
+            return finishBooking(bought?.sku ?? '', {
+                booked,
+                resort: bought?.name,
+                quantity: bought?.quantity,
+                protocol: 'acp',
+                payer: 'curless-wallet (separate connector)',
+                status: order.status,
+                orderId: order.order?.id ?? sessionId,
+                message: `Checkout ${sessionId} completed with the credential the wallet minted (${order.status}).`,
+            });
+        }
+        // ── mode 3: hand the person a link and let them approve in a browser ──
+        if (req.params.name === 'pay_sinocare_hosted') {
+            if (!TOKEN) {
+                return text({ error: 'sinocare-demo: AGENTBANK_AGENT_TOKEN is not set' });
+            }
+            const sku = String(args.sku ?? '');
+            const quantity = Math.max(Number(args.quantity) || 1, 1);
+            const session = await backend('/checkout-acp', {
+                method: 'POST',
+                body: JSON.stringify({ sku, quantity, ...(BUYER ? { buyer: BUYER } : {}) }),
+            });
+            return text({
+                booked: false,
+                awaitingPayment: true,
+                message: '在浏览器里打开这个链接,看清金额再批准。这里还没有扣任何款。',
+                payUrl: `${API_BASE}/buyer/pay?session=${encodeURIComponent(session.sessionId)}`,
+                sessionId: session.sessionId,
+                resort: session.name,
+                total: session.amountDisplay,
+                // Say plainly that nothing has been paid yet. A tool that returns a
+                // link and a resort name reads like a receipt if it does not.
+                paid: false,
+                merchantId: session.merchantId,
+                next: 'show the person this link. Nothing has been charged yet — they approve it in their browser. Then call get_sinocare_order_status with this sessionId.',
+            });
+        }
+        if (req.params.name === 'get_sinocare_order_status') {
+            if (!TOKEN) {
+                return text({ error: 'sinocare-demo: AGENTBANK_AGENT_TOKEN is not set' });
+            }
+            const sessionId = String(args.sessionId ?? '');
+            const merchantId = String(args.merchantId ?? '');
+            const session = await readCheckoutSession(acp(merchantId), sessionId);
+            const paid = session.status === 'completed';
+            const bought = purchaseOf(session);
+            // The approval happened in a browser, so THIS is the only moment the demo
+            // learns of it. Record the booking here or it is never recorded at all.
+            return finishBooking(paid ? (bought?.sku ?? '') : '', {
+                booked: paid,
+                paid,
+                sessionId,
+                status: session.status,
+                resort: bought?.name,
+                quantity: bought?.quantity,
+                protocol: 'acp',
+                payer: 'curless-wallet (hosted approval)',
+                orderId: sessionId,
+                message: paid
+                    ? 'Paid — the buyer approved it in their browser.'
+                    : 'Not paid yet. They have not finished approving it.',
+            });
+        }
+        if (req.params.name === 'buy_sinocare_product_ucp') {
+            if (!TOKEN) {
+                return {
+                    content: [{ type: 'text', text: 'set AGENTBANK_AGENT_TOKEN (a test agent:execute key)' }],
+                    isError: true,
+                };
+            }
+            const sku = String(args.sku ?? '');
+            const quantity = Math.max(Number(args.quantity) || 1, 1);
+            const pay = args.pay === 'usdc'
+                ? 'usdc'
+                : args.pay === 'usdc-sol'
+                    ? 'usdc-sol'
+                    : args.pay === 'rlusd'
+                        ? 'rlusd'
+                        : 'card';
+            // USDC path: the merchant quotes the UCP session in USDC (a small test
+            // charge); the gateway freezes an x402 challenge on it, and this buyer pays
+            // with an X-PAYMENT (EIP-3009) at /complete — settled over the stablecoin
+            // rail, same money-movement as buy_sinocare_product_x402 but via a UCP
+            // session (one protocol, two payment methods).
+            if (pay === 'usdc') {
+                const session = await backend('/checkout-ucp', {
+                    method: 'POST',
+                    body: JSON.stringify({ sku, quantity, pay: 'usdc', ...(BUYER ? { buyer: BUYER } : {}) }),
+                });
+                const reqs = session.x402?.accepts?.[0];
+                if (!reqs)
+                    throw new Error('USDC UCP session missing its x402 requirements');
+                // Pre-flight balance check (skipped in throwaway-key / STUB mode).
+                const buyer = await buyerSigner();
+                if (buyer) {
+                    const have = await usdcBalance({
+                        network: reqs.network,
+                        owner: buyer.address,
+                        token: reqs.asset,
+                    });
+                    if (have < BigInt(session.amount)) {
+                        const onTestnet = reqs.network === 'base-sepolia';
+                        return text({
+                            booked: false,
+                            reason: 'insufficient_usdc',
+                            wallet: buyer.address,
+                            network: reqs.network,
+                            have: fmtUsdc(have),
+                            need: fmtUsdc(BigInt(session.amount)),
+                            faucet: onTestnet ? 'https://faucet.circle.com' : undefined,
+                            message: `Buyer wallet ${buyer.address} has ${fmtUsdc(have)} on ${reqs.network}, needs ${fmtUsdc(BigInt(session.amount))}.${onTestnet ? ' Top up at https://faucet.circle.com and retry.' : ' Fund it with USDC on Base and retry.'}`,
+                        });
+                    }
+                }
+                // Sign the frozen challenge, then complete the UCP session with an
+                // X-PAYMENT header — the gateway settles it over the stablecoin rail.
+                const xPayment = await signX402(reqs);
+                const paidRes = await fetch(`${API_BASE}/ucp/${encodeURIComponent(session.merchantId)}/checkout-sessions/${encodeURIComponent(session.sessionId)}/complete`, {
+                    method: 'POST',
+                    headers: {
+                        'content-type': 'application/json',
+                        authorization: `Bearer ${TOKEN}`,
+                        'x-payment': xPayment,
+                    },
+                    body: JSON.stringify({ payment: {} }),
+                });
+                const paid = (await paidRes.json());
+                if (paidRes.status !== 200) {
+                    throw new Error(`ucp usdc settle -> ${paidRes.status}: ${JSON.stringify(paid)}`);
+                }
+                const paidUsdc = fmtUsdc(BigInt(session.amount));
+                return finishBooking(sku, {
+                    booked: paid.status === 'completed',
+                    resort: session.name,
+                    quantity,
+                    protocol: 'ucp',
+                    payer: 'agent-key (UCP)',
+                    payWith: 'usdc',
+                    paidUsdc: `${paidUsdc} (fixed test charge, merchant-quoted)`,
+                    payTo: reqs.payTo,
+                    network: reqs.network,
+                    paymentAuthorization: 'x402 EIP-3009 (signed + settled over the stablecoin rail)',
+                    status: paid.status,
+                    orderId: paid.id,
+                    sessionId: session.sessionId,
+                    message: `Booked ${session.name} × ${quantity} — paid ${paidUsdc} via UCP + USDC (x402) to ${reqs.payTo} (${paid.status}).`,
+                });
+            }
+            // USDC-on-Solana path: the merchant quotes the UCP session in USDC on Solana;
+            // the gateway freezes an SVM x402 challenge on it, and this buyer PARTIALLY
+            // signs an SPL transfer (facilitator co-signs feePayer + submits) at /complete —
+            // same UCP wire as the EVM USDC path, only the chain flips. Proves "UCP supports
+            // x402" is chain-agnostic.
+            if (pay === 'usdc-sol') {
+                const secretKey = await solanaBuyerSecret();
+                if (!secretKey) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'set SOLANA_BUYER_SECRET (a devnet Solana secret key holding USDC) to pay USDC-on-Solana over UCP',
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const session = await backend('/checkout-ucp', {
+                    method: 'POST',
+                    body: JSON.stringify({
+                        sku,
+                        quantity,
+                        pay: 'usdc-sol',
+                        ...(BUYER ? { buyer: BUYER } : {}),
+                    }),
+                });
+                const reqs = session.x402?.accepts?.[0];
+                if (!reqs)
+                    throw new Error('USDC-Solana UCP session missing its x402 requirements');
+                const owner = await addressFromSecretKey(secretKey);
+                const have = await solanaUsdcBalance(owner, reqs.asset);
+                const need = Number(reqs.maxAmountRequired);
+                if (have !== null && have < need) {
+                    return text({
+                        booked: false,
+                        reason: 'insufficient_usdc_solana',
+                        wallet: owner,
+                        network: reqs.network,
+                        have: `${(have / 1e6).toFixed(6)} USDC`,
+                        need: `${(need / 1e6).toFixed(6)} USDC`,
+                        faucet: 'https://faucet.circle.com',
+                        message: `Buyer wallet ${owner} has ${(have / 1e6).toFixed(6)} USDC on ${reqs.network}, needs ${(need / 1e6).toFixed(6)}. Top up devnet USDC at https://faucet.circle.com (Solana Devnet) and retry.`,
+                    });
+                }
+                // Partially sign the frozen SVM challenge, then complete the UCP session with
+                // the X-PAYMENT — the gateway settles it over the stablecoin rail (x402.org).
+                const xPayment = await signSolanaX402Payment({
+                    requirements: reqs,
+                    secretKey,
+                    rpcUrl: SOLANA_RPC,
+                });
+                const paidRes = await fetch(`${API_BASE}/ucp/${encodeURIComponent(session.merchantId)}/checkout-sessions/${encodeURIComponent(session.sessionId)}/complete`, {
+                    method: 'POST',
+                    headers: {
+                        'content-type': 'application/json',
+                        authorization: `Bearer ${TOKEN}`,
+                        'x-payment': xPayment,
+                    },
+                    body: JSON.stringify({ payment: {} }),
+                });
+                const paid = (await paidRes.json());
+                if (paidRes.status !== 200) {
+                    throw new Error(`ucp usdc-sol settle -> ${paidRes.status}: ${JSON.stringify(paid)}`);
+                }
+                const paidUsdc = `${(need / 1e6).toFixed(6)} USDC`;
+                return finishBooking(sku, {
+                    booked: paid.status === 'completed',
+                    resort: session.name,
+                    quantity,
+                    protocol: 'ucp',
+                    payer: 'agent-key (UCP)',
+                    payWith: 'usdc-sol',
+                    paidUsdc: `${paidUsdc} (fixed test charge, merchant-quoted)`,
+                    payTo: reqs.payTo,
+                    network: reqs.network,
+                    paymentAuthorization: 'x402 SVM transfer (partially signed; facilitator co-signs feePayer + submits)',
+                    status: paid.status,
+                    orderId: paid.id,
+                    sessionId: session.sessionId,
+                    message: `Booked ${session.name} × ${quantity} — paid ${paidUsdc} via UCP + USDC on Solana to ${reqs.payTo} (${paid.status}).`,
+                });
+            }
+            // RLUSD path: the merchant quotes the UCP session in RLUSD; the gateway
+            // freezes an XRPL x402 challenge on it, and this buyer signs a standard XRPL
+            // Payment (Ed25519, no gas — buyer pays the tiny XRPL fee) which the self-
+            // hosted facilitator submits on-ledger. Same money-movement as
+            // buy_sinocare_product_rlusd, but over a UCP session — the SAME UCP wire the
+            // card/USDC paths use, only the currency flips the chain to the XRP Ledger.
+            if (pay === 'rlusd') {
+                const wallet = xrplBuyer();
+                if (!wallet) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'set XRPL_BUYER_SEED (an sEd… testnet seed holding RLUSD + a little test XRP) to pay RLUSD bookings',
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const session = await backend('/checkout-ucp', {
+                    method: 'POST',
+                    body: JSON.stringify({ sku, quantity, pay: 'rlusd', ...(BUYER ? { buyer: BUYER } : {}) }),
+                });
+                const reqs = session.x402?.accepts?.[0];
+                if (!reqs)
+                    throw new Error('RLUSD UCP session missing its x402 requirements');
+                // One XRPL connection for the balance pre-flight AND the signing autofill
+                // (same as buy_sinocare_product_rlusd): sign the merchant's frozen quote.
+                const issuer = reqs.extra?.issuer;
+                const preflight = await withXrplClient(async (client) => {
+                    const have = issuer
+                        ? await rlusdBalance(client, wallet.classicAddress, reqs.asset, issuer)
+                        : '0';
+                    if (Number(have) < Number(reqs.maxAmountRequired)) {
+                        return { have, xPayment: null };
+                    }
+                    return { have, xPayment: await signXrpl(client, reqs, wallet) };
+                });
+                if (preflight.xPayment === null) {
+                    return text({
+                        booked: false,
+                        reason: 'insufficient_rlusd',
+                        wallet: wallet.classicAddress,
+                        network: reqs.network,
+                        have: `${preflight.have} RLUSD`,
+                        need: `${reqs.maxAmountRequired} RLUSD`,
+                        message: `Buyer wallet ${wallet.classicAddress} holds ${preflight.have} RLUSD, needs ${reqs.maxAmountRequired}. Fund it with testnet RLUSD (+ a little test XRP for the fee) and retry.`,
+                    });
+                }
+                // Complete the UCP session with the signed XRPL Payment as an X-PAYMENT —
+                // the gateway settles it over the stablecoin rail (XRPL facilitator).
+                const paidRes = await fetch(`${API_BASE}/ucp/${encodeURIComponent(session.merchantId)}/checkout-sessions/${encodeURIComponent(session.sessionId)}/complete`, {
+                    method: 'POST',
+                    headers: {
+                        'content-type': 'application/json',
+                        authorization: `Bearer ${TOKEN}`,
+                        'x-payment': preflight.xPayment,
+                    },
+                    body: JSON.stringify({ payment: {} }),
+                });
+                const paid = (await paidRes.json());
+                if (paidRes.status !== 200) {
+                    throw new Error(`ucp rlusd settle -> ${paidRes.status}: ${JSON.stringify(paid)}`);
+                }
+                return finishBooking(sku, {
+                    booked: paid.status === 'completed',
+                    resort: session.name,
+                    quantity,
+                    protocol: 'ucp',
+                    payer: 'agent-key (UCP)',
+                    payWith: 'rlusd',
+                    paidRlusd: `${reqs.maxAmountRequired} RLUSD (fixed test charge, merchant-quoted)`,
+                    payTo: reqs.payTo,
+                    network: reqs.network,
+                    paymentAuthorization: 'x402 XRPL Payment (Ed25519, signed + settled over the stablecoin rail)',
+                    status: paid.status,
+                    orderId: paid.id,
+                    sessionId: session.sessionId,
+                    message: `Booked ${session.name} × ${quantity} — paid ${reqs.maxAmountRequired} RLUSD via UCP + RLUSD (x402 on the XRP Ledger) to ${reqs.payTo} (${paid.status}).`,
+                });
+            }
+            // CARD path (default).
+            // 1. Sinocare prices the resort + opens a merchant-quoted UCP session,
+            //    returning a merchant-signed AP2 CartMandate for it.
+            const session = await backend('/checkout-ucp', {
+                method: 'POST',
+                body: JSON.stringify({ sku, quantity, ...(BUYER ? { buyer: BUYER } : {}) }),
+            });
+            // 2. This buyer agent authorizes payment with an AP2 PaymentMandate — a
+            //    real ES256 JWS bound to the cart's hash (UCP AP2 Mandates extension).
+            //    Programmatic completion, no human trusted-UI handoff; the gateway
+            //    cryptographically verifies the mandate, then settles on the card rail.
+            const paymentMandate = await signPaymentMandate({
+                cartHash: session.cartMandate.cartHash,
+                method: { handler: 'card', type: 'card', credential: PAYMENT_TOKEN },
+                amount: session.amount,
+                currency: session.currency,
+            });
+            // Attach the standing authorization if one is active — the gateway then
+            // checks this booking is within the user's delegated cap. Drop it if expired.
+            const mandate = { payment_mandate: paymentMandate };
+            let underAuthorization = false;
+            if (agentBudget) {
+                if (Date.parse(agentBudget.expiresAt) < Date.now()) {
+                    agentBudget = null; // expired — book normally (no standing auth)
+                    saveBudget(null);
+                }
+                else {
+                    mandate.intent_mandate = agentBudget.mandate;
+                    underAuthorization = true;
+                }
+            }
+            const url = `${API_BASE}/ucp/${encodeURIComponent(session.merchantId)}/checkout-sessions/${encodeURIComponent(session.sessionId)}/complete`;
+            const res = await fetch(url, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json', authorization: `Bearer ${TOKEN}` },
+                body: JSON.stringify({ payment: { mandate } }),
+            });
+            if (!res.ok) {
+                const errText = await res.text().catch(() => '');
+                // A standing-authorization rejection (over cap / expired) → a clean,
+                // explanatory result instead of a raw error, so the agent can react.
+                if (underAuthorization &&
+                    /intent mandate rejected|exceeds_intent_max_amount|intent_mandate_expired/.test(errText)) {
+                    return text({
+                        booked: false,
+                        blockedBy: 'standing-authorization',
+                        resort: session.name,
+                        total: session.amountDisplay,
+                        authorizedCap: `€${agentBudget?.maxAmountEur.toLocaleString('en-IE')}`,
+                        message: `Blocked: ${session.name} (${session.amountDisplay}) is over your standing authorization (cap €${agentBudget?.maxAmountEur}, or it expired). Raise it with authorize_agent_budget, or book a cheaper resort.`,
+                    });
+                }
+                throw new Error(`ucp complete -> ${res.status}: ${errText}`);
+            }
+            const out = (await res.json());
+            return finishBooking(sku, {
+                booked: out.status === 'completed',
+                resort: session.name,
+                quantity,
+                total: session.amountDisplay,
+                protocol: 'ucp',
+                payer: 'agent-key (UCP)',
+                // The payment was ALWAYS authorized by a signed AP2 PaymentMandate — this
+                // says so explicitly so it can't be misread as "unauthorized".
+                paymentAuthorization: 'AP2 PaymentMandate (signed + verified)',
+                // The OPTIONAL standing budget (authorize_agent_budget): applied here, or
+                // not set for this booking. "not set" ≠ unauthorized — see above.
+                standingBudget: underAuthorization
+                    ? `applied (within your €${agentBudget?.maxAmountEur} cap, no per-booking confirm)`
+                    : 'not set',
+                status: out.status,
+                orderId: out.id,
+                message: `Booked ${session.name} × ${quantity} — ${session.amountDisplay} charged via UCP + AP2 PaymentMandate (${out.status})${underAuthorization ? ` — under your standing €${agentBudget?.maxAmountEur} authorization, no per-booking confirm` : ''}.`,
+            });
+        }
+        if (req.params.name === 'buy_sinocare_product_x402') {
+            if (!TOKEN) {
+                return {
+                    content: [{ type: 'text', text: 'set AGENTBANK_AGENT_TOKEN (a test agent:execute key)' }],
+                    isError: true,
+                };
+            }
+            const sku = String(args.sku ?? '');
+            const quantity = Math.max(Number(args.quantity) || 1, 1);
+            // Solana path (chain=solana): USDC over Solana (SVM). The merchant quotes a
+            // Solana USDC session; this buyer builds + PARTIALLY signs an SPL transfer,
+            // the x402.org facilitator co-signs as feePayer + sponsors the fee + submits.
+            // Same merchant-quoted session shape as the EVM/USDC path, only the chain flips.
+            if (args.chain === 'solana') {
+                const secretKey = await solanaBuyerSecret();
+                if (!secretKey) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'set SOLANA_BUYER_SECRET (a devnet Solana secret key — solana-keygen JSON array or base58 — holding devnet USDC) to pay USDC-on-Solana bookings',
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const { merchantId } = await backend('/health');
+                const session = await backend('/checkout-x402', {
+                    method: 'POST',
+                    body: JSON.stringify({ sku, quantity, currency: 'USDC', chain: 'solana' }),
+                });
+                const reqs = session.accepts?.[0];
+                if (!reqs)
+                    throw new Error('merchant Solana USDC session missing payment requirements');
+                // Balance pre-flight (skip on RPC error) against the merchant's quote.
+                const owner = await addressFromSecretKey(secretKey);
+                const have = await solanaUsdcBalance(owner, reqs.asset);
+                const need = Number(reqs.maxAmountRequired);
+                if (have !== null && have < need) {
+                    return text({
+                        booked: false,
+                        reason: 'insufficient_usdc_solana',
+                        wallet: owner,
+                        network: reqs.network,
+                        have: `${(have / 1e6).toFixed(6)} USDC`,
+                        need: `${(need / 1e6).toFixed(6)} USDC`,
+                        faucet: 'https://faucet.circle.com',
+                        message: `Buyer wallet ${owner} has ${(have / 1e6).toFixed(6)} USDC on ${reqs.network}, needs ${(need / 1e6).toFixed(6)}. Top up devnet USDC at https://faucet.circle.com (Solana Devnet) and retry.`,
+                    });
+                }
+                // Sign the frozen quote (facilitator sponsors the fee), then pay { sessionId }.
+                const xPayment = await signSolanaX402Payment({
+                    requirements: reqs,
+                    secretKey,
+                    rpcUrl: SOLANA_RPC,
+                });
+                const paidRes = await fetch(`${API_BASE}/x402/${encodeURIComponent(merchantId)}/checkout`, {
+                    method: 'POST',
+                    headers: {
+                        'content-type': 'application/json',
+                        authorization: `Bearer ${TOKEN}`,
+                        'x-payment': xPayment,
+                    },
+                    body: JSON.stringify({ sessionId: session.sessionId }),
+                });
+                const paid = (await paidRes.json());
+                if (paidRes.status !== 200) {
+                    throw new Error(`solana x402 settle -> ${paidRes.status}: ${JSON.stringify(paid)}`);
+                }
+                const paidUsdc = `${(need / 1e6).toFixed(6)} USDC`;
+                const cluster = reqs.network === 'solana-devnet' ? '?cluster=devnet' : '';
+                // finishBooking (not text) so a Solana booking is recorded like every other
+                // rail — the card rehydrates to a receipt on reload instead of the picker.
+                return finishBooking(sku, {
+                    booked: paid.status === 'captured',
+                    resort: session.name,
+                    quantity,
+                    protocol: 'x402',
+                    payer: 'buyer chain wallet (x402)',
+                    priceEur: session.priceEur,
+                    paidUsdc: `${paidUsdc} (fixed test charge, merchant-quoted)`,
+                    payTo: reqs.payTo,
+                    network: reqs.network,
+                    paymentAuthorization: 'x402 SVM transfer (partially signed; facilitator co-signs feePayer + submits + sponsors gas)',
+                    status: paid.status,
+                    txHash: paid.txHash,
+                    explorer: paid.txHash
+                        ? `https://explorer.solana.com/tx/${paid.txHash}${cluster}`
+                        : undefined,
+                    paymentIntentId: paid.paymentIntentId,
+                    sessionId: session.sessionId,
+                    message: `Booked ${session.name} × ${quantity} — paid ${paidUsdc} via x402 · USDC on Solana to ${reqs.payTo} (${paid.status}).`,
+                });
+            }
+            const { merchantId } = await backend('/health');
+            // The MERCHANT opens a merchant-quoted x402 session — IT sets the USDC
+            // price (the gateway has no Sinocare catalog). We just pay it; we never
+            // compute or pass the amount. Same shape as the ACP `/checkout-acp` flow.
+            const session = await backend('/checkout-x402', {
+                method: 'POST',
+                body: JSON.stringify({ sku, quantity, ...(BUYER ? { buyer: BUYER } : {}) }),
+            });
+            const reqs = session.accepts?.[0];
+            if (!reqs)
+                throw new Error('merchant x402 session missing payment requirements');
+            // Pre-flight: a real payer key + a real facilitator + an empty wallet = a
+            // cryptic on-chain decline. Check the balance first (skipped in throwaway-
+            // key / STUB mode) against the MERCHANT's quoted amount.
+            const buyer = await buyerSigner();
+            if (buyer) {
+                const have = await usdcBalance({
+                    network: reqs.network,
+                    owner: buyer.address,
+                    token: reqs.asset,
+                });
+                if (have < BigInt(session.amount)) {
+                    const onTestnet = reqs.network === 'base-sepolia';
+                    return text({
+                        booked: false,
+                        reason: 'insufficient_usdc',
+                        wallet: buyer.address,
+                        network: reqs.network,
+                        have: fmtUsdc(have),
+                        need: fmtUsdc(BigInt(session.amount)),
+                        faucet: onTestnet ? 'https://faucet.circle.com' : undefined,
+                        message: `Buyer wallet ${buyer.address} has ${fmtUsdc(have)} on ${reqs.network}, needs ${fmtUsdc(BigInt(session.amount))}.${onTestnet ? ' Top up at https://faucet.circle.com (20 USDC / 2h) and retry.' : ' Fund it with USDC on Base and retry.'}`,
+                    });
+                }
+            }
+            // Sign the merchant's frozen quote, then pay the session — the amount is
+            // set by the merchant; we just reference { sessionId }.
+            const xPayment = await signX402(reqs);
+            const paidRes = await fetch(`${API_BASE}/x402/${encodeURIComponent(merchantId)}/checkout`, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    authorization: `Bearer ${TOKEN}`,
+                    'x-payment': xPayment,
+                },
+                body: JSON.stringify({ sessionId: session.sessionId }),
+            });
+            const paid = (await paidRes.json());
+            if (paidRes.status !== 200) {
+                throw new Error(`x402 settle -> ${paidRes.status}: ${JSON.stringify(paid)}`);
+            }
+            const paidUsdc = fmtUsdc(BigInt(session.amount));
+            return finishBooking(sku, {
+                booked: paid.status === 'captured',
+                resort: session.name,
+                quantity,
+                protocol: 'x402',
+                payer: 'buyer chain wallet (x402)',
+                priceEur: session.priceEur,
+                paidUsdc: `${paidUsdc} (fixed test charge, merchant-quoted)`,
+                payTo: reqs.payTo,
+                network: reqs.network,
+                status: paid.status,
+                txHash: paid.txHash,
+                paymentIntentId: paid.paymentIntentId,
+                sessionId: session.sessionId,
+                message: `Booked ${session.name} × ${quantity} — paid ${paidUsdc} via x402 (merchant-quoted) to ${reqs.payTo} (${paid.status}).`,
+            });
+        }
+        if (req.params.name === 'x402_buyer_wallet') {
+            const buyer = await buyerSigner();
+            if (!buyer) {
+                return text({
+                    configured: false,
+                    message: 'No buyer signer configured — x402 signs with a throwaway, unfunded key (only settles under a STUB facilitator). Set X402_SIGNER=cdp (+ CDP_API_KEY_ID/_SECRET/_WALLET_SECRET) for a CDP Server Wallet, or X402_PAYER_PRIVATE_KEY for a local key, to pay real testnet/mainnet USDC.',
+                });
+            }
+            const [sepolia, mainnet] = await Promise.all([
+                usdcBalance({ network: 'base-sepolia', owner: buyer.address }),
+                usdcBalance({ network: 'base', owner: buyer.address }),
+            ]);
+            return text({
+                address: buyer.address,
+                balances: { 'base-sepolia': fmtUsdc(sepolia), base: fmtUsdc(mainnet) },
+                faucet: 'https://faucet.circle.com (Base Sepolia USDC — 20 / 2h per address)',
+                note: 'Fund this address with USDC to pay for x402 bookings. Testnet: use the faucet. Mainnet: send real USDC on Base.',
+            });
+        }
+        if (req.params.name === 'buy_sinocare_product_rlusd') {
+            if (!TOKEN) {
+                return {
+                    content: [{ type: 'text', text: 'set AGENTBANK_AGENT_TOKEN (a test agent:execute key)' }],
+                    isError: true,
+                };
+            }
+            const wallet = xrplBuyer();
+            if (!wallet) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'set XRPL_BUYER_SEED (an sEd… testnet seed holding RLUSD + a little test XRP) to pay RLUSD bookings',
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const sku = String(args.sku ?? '');
+            const quantity = Math.max(Number(args.quantity) || 1, 1);
+            const { merchantId } = await backend('/health');
+            // The MERCHANT opens a merchant-quoted RLUSD session — IT sets the price
+            // (the gateway holds no Sinocare catalog). We just pay it. Same shape as the
+            // USDC x402 flow, only `currency: 'RLUSD'` flips the chain to the XRP Ledger.
+            const session = await backend('/checkout-x402', {
+                method: 'POST',
+                body: JSON.stringify({ sku, quantity, currency: 'RLUSD' }),
+            });
+            const reqs = session.accepts?.[0];
+            if (!reqs)
+                throw new Error('merchant RLUSD session missing payment requirements');
+            // One XRPL connection for both the balance pre-flight AND the signing
+            // autofill. Pre-flight catches an unfunded / trust-line-less wallet before
+            // we bother signing; on enough balance we sign the merchant's frozen quote.
+            const issuer = reqs.extra?.issuer;
+            const preflight = await withXrplClient(async (client) => {
+                const have = issuer
+                    ? await rlusdBalance(client, wallet.classicAddress, reqs.asset, issuer)
+                    : '0';
+                if (Number(have) < Number(reqs.maxAmountRequired)) {
+                    return { have, xPayment: null };
+                }
+                return { have, xPayment: await signXrpl(client, reqs, wallet) };
+            });
+            if (preflight.xPayment === null) {
+                return text({
+                    booked: false,
+                    reason: 'insufficient_rlusd',
+                    wallet: wallet.classicAddress,
+                    network: reqs.network,
+                    have: `${preflight.have} RLUSD`,
+                    need: `${reqs.maxAmountRequired} RLUSD`,
+                    message: `Buyer wallet ${wallet.classicAddress} holds ${preflight.have} RLUSD, needs ${reqs.maxAmountRequired}. Fund it with testnet RLUSD (+ a little test XRP for the fee) and retry.`,
+                });
+            }
+            // Pay the session (amount is merchant-set; we just reference { sessionId }).
+            const xPayment = preflight.xPayment;
+            const paidRes = await fetch(`${API_BASE}/x402/${encodeURIComponent(merchantId)}/checkout`, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    authorization: `Bearer ${TOKEN}`,
+                    'x-payment': xPayment,
+                },
+                body: JSON.stringify({ sessionId: session.sessionId }),
+            });
+            const paid = (await paidRes.json());
+            if (paidRes.status !== 200) {
+                throw new Error(`rlusd settle -> ${paidRes.status}: ${JSON.stringify(paid)}`);
+            }
+            return finishBooking(sku, {
+                booked: paid.status === 'captured',
+                resort: session.name,
+                quantity,
+                protocol: 'x402',
+                payer: 'buyer chain wallet (x402)',
+                priceEur: session.priceEur,
+                paidRlusd: `${reqs.maxAmountRequired} RLUSD (fixed test charge, merchant-quoted)`,
+                payTo: reqs.payTo,
+                network: reqs.network,
+                status: paid.status,
+                txHash: paid.txHash,
+                explorer: paid.txHash ? `https://testnet.xrpl.org/transactions/${paid.txHash}` : undefined,
+                paymentIntentId: paid.paymentIntentId,
+                sessionId: session.sessionId,
+                message: `Booked ${session.name} × ${quantity} — paid ${reqs.maxAmountRequired} RLUSD via x402 on the XRP Ledger to ${reqs.payTo} (${paid.status}).`,
+            });
+        }
+        if (req.params.name === 'buy_sinocare_product_skyfire') {
+            if (!SKYFIRE_BUYER_API_KEY || !SKYFIRE_SELLER_SERVICE_ID) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'set SKYFIRE_BUYER_API_KEY + SKYFIRE_SELLER_SERVICE_ID to mint a Skyfire pay token (the merchant backend charges it via the merchant SDK)',
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const sku = String(args.sku ?? '');
+            const quantity = Math.max(Number(args.quantity) || 1, 1);
+            const resort = await backend(`/catalog/${encodeURIComponent(sku)}`).catch(() => null);
+            const resortName = resort?.name ?? sku;
+            // The BUYER mints a Skyfire-signed PAY token (Skyfire's key signs it — the
+            // buyer can't self-sign), then presents it to the MERCHANT backend, which
+            // charges it via the merchant SDK (checkout.chargeSkyfire → the gateway
+            // verifies it against Skyfire's live JWKS and records/settles). Three-layer:
+            // buyer mints, merchant charges — the demo never calls the gateway directly.
+            const token = await mintSkyfirePayToken(SKYFIRE_TEST_AMOUNT);
+            const out = await backend('/checkout-skyfire', { method: 'POST', body: JSON.stringify({ sku, token }) });
+            const amountStr = out.amount != null && out.currency
+                ? `${(out.amount / 1e6).toFixed(6)} ${out.currency}`
+                : `~${SKYFIRE_TEST_AMOUNT} USD`;
+            const status = out.status ?? 'initiated';
+            const captured = out.settled === true || status === 'captured';
+            // Two terminal states, both a successful booking: CAPTURED (seller-charge
+            // configured → real USDC moved) vs VERIFIED+RECORDED (no seller key → PI
+            // initiated, no money moved).
+            const message = captured
+                ? `Booked ${resortName} × ${quantity} via Skyfire KYAPay — ${amountStr} charged (Skyfire redeemed the PAY token buyer → seller) and the payment intent is captured (PI ${status}). agentbank verified the agent + payment authorization against Skyfire's live JWKS, then settled it via Skyfire seller-charge.`
+                : `Booked ${resortName} × ${quantity} via Skyfire KYAPay — ${amountStr} verified against Skyfire's live JWKS + recorded (PI ${status}). agentbank verified the agent + payment authorization and recorded it; no seller key is configured, so it did not auto-capture and no money moved.`;
+            return finishBooking(sku, {
+                booked: out.agent?.verified === true,
+                resort: resortName,
+                quantity,
+                protocol: 'skyfire',
+                payer: 'skyfire buyer token',
+                paidUsdc: captured
+                    ? `${amountStr} (Skyfire KYAPay — charged, captured)`
+                    : `${amountStr} (Skyfire KYAPay authorization, recorded)`,
+                buyerAgent: out.agent?.subject,
+                paymentAuthorization: 'Skyfire KYAPay PAY token (Skyfire ES256-signed, verified against the live JWKS)',
+                status,
+                orderId: out.paymentIntentId,
+                message,
+            });
+        }
+        if (req.params.name === 'buy_sinocare_product_mpp') {
+            if (!TEMPO_BUYER_PRIVATE_KEY) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'set TEMPO_BUYER_PRIVATE_KEY (a funded Tempo testnet key) to pay via MPP · Tempo',
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const sku = String(args.sku ?? '');
+            const quantity = Math.max(Number(args.quantity) || 1, 1);
+            const resort = await backend(`/catalog/${encodeURIComponent(sku)}`).catch(() => null);
+            const resortName = resort?.name ?? sku;
+            // Three-layer MPP · Tempo — the demo talks only to the MERCHANT backend,
+            // which mediates the HTTP-402 dance via the merchant SDK (checkout.openMPP):
+            // 1. ask the backend to open the charge → it returns the 402 challenge;
+            // 2. the buyer pays it on Tempo (SDK @curless/agentbank-protocols/tempo);
+            // 3. hand the credential back to the backend → it settles.
+            const opened = await backend('/checkout-mpp', {
+                method: 'POST',
+                body: JSON.stringify({ sku }),
+            });
+            if (opened.status !== 'payment_required' || !opened.wwwAuthenticate) {
+                throw new Error(`mpp open expected a challenge, got ${JSON.stringify(opened)}`);
+            }
+            const { credential, txHash } = await payMppTempoChallenge({
+                wwwAuthenticate: opened.wwwAuthenticate,
+                privateKey: TEMPO_BUYER_PRIVATE_KEY,
+                rpcUrl: TEMPO_RPC,
+            }).catch((e) => {
+                throw new Error(`mpp tempo pay failed (${e.message}) — is the gateway's TEMPO_RECIPIENT set + the buyer wallet funded?`);
+            });
+            const out = await backend('/checkout-mpp', { method: 'POST', body: JSON.stringify({ sku, credential }) });
+            const paidStr = `${(MPP_TEMPO_TEST_AMOUNT / 1e6).toFixed(6)} pathUSD (Tempo TIP-20, on-chain)`;
+            const settled = out.status === 'settled';
+            return finishBooking(sku, {
+                booked: settled,
+                resort: resortName,
+                quantity,
+                protocol: 'mpp',
+                payer: 'buyer chain wallet (MPP·Tempo)',
+                total: paidStr,
+                paidUsdc: paidStr,
+                status: settled ? 'captured' : out.status,
+                orderId: out.paymentIntentId,
+                txHash,
+                message: `Booked ${resortName} × ${quantity} via MPP · Tempo — paid ${paidStr} to Sinocare on the Tempo chain (tx ${txHash.slice(0, 14)}…). The merchant backend issued the HTTP-402 challenge (via the merchant SDK) and, after the buyer paid on-chain, VERIFIED the TIP-20 transfer by hash — capturing the payment intent${out.paymentIntentId ? ` (PI ${out.paymentIntentId})` : ''}.`,
+            });
+        }
+        if (req.params.name === 'xrpl_buyer_wallet') {
+            const wallet = xrplBuyer();
+            if (!wallet) {
+                return text({
+                    configured: false,
+                    message: 'No XRPL buyer wallet — set XRPL_BUYER_SEED (an sEd… testnet seed) to pay RLUSD bookings. Fund it with testnet RLUSD (a trust line to the RLUSD issuer) + a little test XRP for the fee/reserve.',
+                });
+            }
+            const issuer = process.env.XRPL_RLUSD_ISSUER ?? 'rQhWct2fv4Vc4KRjRgMrxa8xPN9Zx9iLKV';
+            const RLUSD_HEX = '524C555344000000000000000000000000000000';
+            const have = await withXrplClient((client) => rlusdBalance(client, wallet.classicAddress, RLUSD_HEX, issuer));
+            return text({
+                address: wallet.classicAddress,
+                network: 'xrpl:1 (testnet)',
+                rlusd: `${have} RLUSD`,
+                issuer,
+                explorer: `https://testnet.xrpl.org/accounts/${wallet.classicAddress}`,
+                note: 'Fund this address with testnet RLUSD (needs a trust line to the RLUSD issuer) + a little test XRP for the fee/reserve to pay RLUSD bookings.',
+            });
+        }
+        if (req.params.name === 'list_my_orders') {
+            // The merchant backend lists its orders (single-merchant demo = my orders).
+            const { orders } = await backend('/orders');
+            // Amount is minor units at the order's currency scale: 2 dp for fiat (EUR/USD),
+            // 6 dp for stablecoins (USDC/RLUSD). Dividing by 100 for a 50000 RLUSD order
+            // would show 500 instead of 0.05 — scale by the currency's own decimals.
+            const dp = (cur) => (['USDC', 'RLUSD', 'USDT'].includes(cur) ? 6 : 2);
+            const fmt = (amt, cur) => `${(amt / 10 ** dp(cur)).toLocaleString('en-IE', { maximumFractionDigits: dp(cur) })} ${cur}`;
+            const view = {
+                view: 'orders',
+                orders: orders.map((o) => ({
+                    orderId: o.id,
+                    // A pending request outranks the payment status HERE, because this list
+                    // is where the buyer decides whether to ask. `paid` beside a live
+                    // "申请退款" button, on a booking they already asked about, invites them
+                    // to ask twice. Kept in the gateway's own English vocabulary — the rest
+                    // of the pills are (robin, 2026-07-28).
+                    status: o.refundRequest
+                        ? o.refundRequest.status === 'approved'
+                            ? 'refund approved'
+                            : 'refund requested'
+                        : o.status,
+                    // The card hides its button on this — an explicit flag, not a substring
+                    // of the status, so the two can never drift apart.
+                    refundPending: Boolean(o.refundRequest),
+                    resort: o.lineItems?.map((li) => `${li.name} ×${li.quantity}`).join(', ') ?? '',
+                    total: fmt(o.amount, o.currency),
+                    protocol: o.protocol,
+                    date: o.createdAt?.slice(0, 10) ?? '',
+                })),
+            };
+            // Render the orders CARD (structuredContent + _meta), not a plain JSON table —
+            // the card lists each booking with a 申请退款 button.
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: orders.length
+                            ? `You have ${orders.length} Sinocare booking(s) — shown in the card (each settled one has a 申请退款 button).`
+                            : 'No Sinocare bookings yet.',
+                    },
+                ],
+                structuredContent: view,
+                _meta: CHECKOUT_UI_META,
+            };
+        }
+        if (req.params.name === 'request_refund') {
+            if (!TOKEN) {
+                return {
+                    content: [{ type: 'text', text: 'set AGENTBANK_AGENT_TOKEN (a test agent:execute key)' }],
+                    isError: true,
+                };
+            }
+            const orderId = String(args.orderId ?? '');
+            if (!orderId)
+                throw new Error('orderId is required (from list_my_orders)');
+            // The BUYER asks the gateway directly (its own agent token) — the merchant
+            // then approves/rejects from its MCP. Money moves only on approval+Curless.
+            const res = await fetch(`${API_BASE}/v1/refund-requests`, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json', authorization: `Bearer ${TOKEN}` },
+                body: JSON.stringify({ orderId, reason: args.reason ? String(args.reason) : undefined }),
+            });
+            const out = (await res.json());
+            if (!res.ok) {
+                // The gateway's typed errors carry a message written for a human ("this
+                // order has already been refunded", "already has an open refund
+                // request"). Surface THAT — a raw JSON dump of the envelope is what the
+                // buyer used to get, which tells them nothing about what to do next.
+                const detail = (typeof out.error === 'object' && out.error?.message) ||
+                    (typeof out.error === 'string' ? out.error : '') ||
+                    out.message ||
+                    `HTTP ${res.status}`;
+                throw new Error(String(detail));
+            }
+            return text({
+                requested: true,
+                refundRequestId: out.refundRequest?.id,
+                status: out.refundRequest?.status,
+                message: `Refund requested for ${orderId}. Sinocare will review and approve or reject it.`,
+            });
+        }
+        if (req.params.name === 'authorize_agent_budget') {
+            const maxAmountEur = Number(args.maxAmountEur);
+            if (!Number.isFinite(maxAmountEur) || maxAmountEur <= 0) {
+                throw new Error('maxAmountEur must be a positive number (EUR)');
+            }
+            const hours = Math.max(1, Math.floor(Number(args.hours) || 24));
+            const expiresAt = new Date(Date.now() + hours * 3_600_000).toISOString();
+            const maxAmount = Math.round(maxAmountEur * 100); // EUR minor units (cents)
+            // The user signs the delegation as a real AP2 IntentMandate (ES256 JWS).
+            const mandate = await signIntentMandate({
+                prompt: `Autonomous Sinocare booking — up to €${maxAmountEur} for ${hours}h`,
+                constraints: { maxAmount },
+                expiresAt,
+            });
+            agentBudget = { mandate, maxAmountEur, expiresAt };
+            saveBudget(agentBudget); // survive a process restart
+            return text({
+                authorized: true,
+                maxBudgetPerBooking: `€${maxAmountEur.toLocaleString('en-IE')}`,
+                expiresAt,
+                message: `Agent authorized to book Sinocare up to €${maxAmountEur} per booking until ${expiresAt}. It can now complete UCP bookings under that cap without asking you to confirm each one; over-cap or expired bookings are rejected by the gateway.`,
+            });
+        }
+        if (req.params.name === 'agent_budget_status') {
+            if (!agentBudget || Date.parse(agentBudget.expiresAt) < Date.now()) {
+                agentBudget = null;
+                saveBudget(null);
+                return text({
+                    authorized: false,
+                    message: 'No active booking authorization — use authorize_agent_budget to delegate one.',
+                });
+            }
+            return text({
+                authorized: true,
+                maxBudgetPerBooking: `€${agentBudget.maxAmountEur.toLocaleString('en-IE')}`,
+                expiresAt: agentBudget.expiresAt,
+            });
+        }
+        if (req.params.name === 'revoke_agent_budget') {
+            const had = agentBudget !== null;
+            agentBudget = null;
+            saveBudget(null);
+            return text({
+                revoked: had,
+                message: had
+                    ? 'Booking authorization revoked — the agent needs a fresh one to book autonomously.'
+                    : 'No authorization was set.',
+            });
+        }
+        return { content: [{ type: 'text', text: `unknown tool: ${req.params.name}` }], isError: true };
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+    }
+});
+await server.connect(new StdioServerTransport());
+//# sourceMappingURL=index.js.map