@agentwonderland/mcp 0.1.23 → 0.1.25

package/dist/core/payments.d.ts

@@ -9,6 +9,7 @@
  * Users can configure multiple wallets with different chains and select
  * which to use per-request via `--pay-with <wallet-id|chain|card>`.
  */
+import type { AgentRecord } from "./types.js";
 /**
  * Returns a payment-aware fetch for a specific method, or the best
  * available method if none is specified.
@@ -21,6 +22,11 @@ export declare function getPaymentFetch(method?: string): Promise<typeof fetch>;
  * (with default wallet's default chain first) + "card" if configured.
  */
 export declare function getConfiguredMethods(): string[];
+/**
+ * Normalize a requested payment method into the MCP-visible method identifier.
+ * Accepts chain names, wallet IDs, or "card".
+ */
+export declare function normalizePaymentMethod(method: string): string | null;
 /**
  * Human-friendly display name for a payment method identifier.
  */
@@ -31,6 +37,8 @@ export declare function paymentMethodDisplayName(method: string): string;
  * (tempo_usdc, base_usdc, stripe_card).
  */
 export declare function getAcceptedPaymentMethods(): string[];
+export declare function toRegistryPaymentMethod(method: string): string | null;
+export declare function getCompatiblePaymentMethods(agent: Pick<AgentRecord, "payment"> | null | undefined, configuredMethods?: string[]): string[];
 /**
  * Check whether any payment method is configured.
  */

package/dist/core/payments.js

@@ -12,6 +12,18 @@
 import { getConfig, getWallets, getDefaultWallet, getCardConfig, resolveWalletAndChain, getApiUrl, } from "./config.js";
 // Cache per wallet+chain combo to avoid re-initializing
 const fetchCache = new Map();
+const REGISTRY_METHOD_MAP = {
+    tempo: "tempo_usdc",
+    base: "base_usdc",
+    solana: "solana_usdc",
+    card: "stripe_card",
+};
+const METHOD_REGISTRY_MAP = {
+    tempo_usdc: "tempo",
+    base_usdc: "base",
+    solana_usdc: "solana",
+    stripe_card: "card",
+};
 // ── Helpers ─────────────────────────────────────────────────────
 function normalizeKey(key) {
     return (key.startsWith("0x") ? key : `0x${key}`);
@@ -19,8 +31,21 @@ function normalizeKey(key) {
 function cacheKey(walletId, chain) {
     return `${walletId}:${chain}`;
 }
+function cardCacheKey() {
+    const card = getCardConfig();
+    if (!card)
+        return null;
+    return `card:${getApiUrl()}:${card.consumerToken}:${card.paymentMethodId ?? ""}`;
+}
+function clearStaleCardCache(activeKey) {
+    for (const key of fetchCache.keys()) {
+        if (key.startsWith("card:") && key !== activeKey) {
+            fetchCache.delete(key);
+        }
+    }
+}
 // ── Per-protocol initializers ───────────────────────────────────
-async function initMpp(wallet) {
+async function initEvmMppForChain(wallet, chain) {
     try {
         const { Mppx, tempo } = await import("mppx/client");
         let account;
@@ -35,8 +60,31 @@ async function initMpp(wallet) {
         else {
             return null;
         }
-        const { baseChargeClient } = await import("./base-charge.js");
-        const mppx = Mppx.create({ methods: [tempo({ account }), baseChargeClient({ account })] });
+        const methods = [];
+        if (chain === "tempo") {
+            methods.push(tempo({ account }));
+        }
+        else {
+            const { baseChargeClient } = await import("./base-charge.js");
+            methods.push(baseChargeClient({ account }));
+        }
+        const mppx = Mppx.create({ methods: methods });
+        return mppx.fetch.bind(mppx);
+    }
+    catch {
+        return null;
+    }
+}
+async function initSolanaMpp(wallet) {
+    try {
+        if (wallet.keyType !== "ows" && !wallet.key) {
+            return null;
+        }
+        const { Mppx } = await import("mppx/client");
+        const { solanaChargeClient } = await import("./solana-charge.js");
+        const mppx = Mppx.create({
+            methods: [solanaChargeClient({ wallet })],
+        });
         return mppx.fetch.bind(mppx);
     }
     catch {
@@ -82,8 +130,14 @@ async function initCard() {
 /**
  * Initialize a payment-aware fetch for a given wallet + chain.
  */
-async function initForChain(wallet, _chain) {
-    return initMpp(wallet);
+async function initForChain(wallet, chain) {
+    if (chain === "solana") {
+        return initSolanaMpp(wallet);
+    }
+    if (chain === "tempo" || chain === "base") {
+        return initEvmMppForChain(wallet, chain);
+    }
+    return null;
 }
 // ── Public API ──────────────────────────────────────────────────
 /**
@@ -95,7 +149,11 @@ async function initForChain(wallet, _chain) {
 export async function getPaymentFetch(method) {
     // Card payment
     if (method === "card") {
-        const ck = "card:card";
+        const ck = cardCacheKey();
+        clearStaleCardCache(ck ?? undefined);
+        if (!ck) {
+            throw new Error('Payment method "card" is not configured. Use the wallet_setup tool to configure a wallet');
+        }
         if (fetchCache.has(ck))
             return fetchCache.get(ck);
         const pf = await initCard();
@@ -126,7 +184,16 @@ export async function getPaymentFetch(method) {
     const defaultMethod = getConfig().defaultPaymentMethod;
     for (const m of configured) {
         if (m === "card") {
-            const ck = "card:card";
+            const ck = cardCacheKey();
+            clearStaleCardCache(ck ?? undefined);
+            if (!ck) {
+                if (m === defaultMethod) {
+                    const others = configured.filter((x) => x !== m);
+                    const altText = others.length > 0 ? ` Available alternatives: ${others.join(", ")}` : "";
+                    throw new Error(`Card payment failed to initialize. Check your card with wallet_status.${altText}`);
+                }
+                continue;
+            }
             if (fetchCache.has(ck))
                 return fetchCache.get(ck);
             const pf = await initCard();
@@ -205,6 +272,16 @@ export function getConfiguredMethods() {
     }
     return methods;
 }
+/**
+ * Normalize a requested payment method into the MCP-visible method identifier.
+ * Accepts chain names, wallet IDs, or "card".
+ */
+export function normalizePaymentMethod(method) {
+    if (method === "card")
+        return "card";
+    const resolved = resolveWalletAndChain(method);
+    return resolved?.chain ?? null;
+}
 /**
  * Human-friendly display name for a payment method identifier.
  */
@@ -224,13 +301,25 @@ export function paymentMethodDisplayName(method) {
  */
 export function getAcceptedPaymentMethods() {
     const methods = getConfiguredMethods();
-    const map = {
-        tempo: "tempo_usdc",
-        base: "base_usdc",
-        solana: "solana_usdc",
-        card: "stripe_card",
-    };
-    return methods.map((m) => map[m]).filter(Boolean);
+    return methods
+        .map((m) => REGISTRY_METHOD_MAP[m])
+        .filter(Boolean);
+}
+export function toRegistryPaymentMethod(method) {
+    const normalized = normalizePaymentMethod(method);
+    if (!normalized)
+        return null;
+    return REGISTRY_METHOD_MAP[normalized] ?? null;
+}
+export function getCompatiblePaymentMethods(agent, configuredMethods = getConfiguredMethods()) {
+    const acceptedPayments = agent?.payment?.accepted_payments;
+    if (!Array.isArray(acceptedPayments) || acceptedPayments.length === 0) {
+        return [...configuredMethods];
+    }
+    const acceptedMethods = new Set(acceptedPayments
+        .map((payment) => METHOD_REGISTRY_MAP[payment])
+        .filter(Boolean));
+    return configuredMethods.filter((method) => acceptedMethods.has(method));
 }
 /**
  * Check whether any payment method is configured.
@@ -242,27 +331,32 @@ export function hasWalletConfigured() {
  * Get address for a specific method, or the first configured one.
  */
 export async function getWalletAddress(method) {
+    let chain;
     let wallet;
     if (method && method !== "card") {
         const resolved = resolveWalletAndChain(method);
         wallet = resolved?.wallet;
+        chain = resolved?.chain;
     }
     else if (!method) {
         wallet = getDefaultWallet();
+        chain = wallet?.defaultChain ?? wallet?.chains[0];
     }
     if (!wallet)
         return null;
     // OWS-managed wallet: derive address via the adapter
     if (wallet.keyType === "ows" && wallet.owsWalletId) {
         try {
-            const { owsAccountFromWalletId } = await import("./ows-adapter.js");
-            const account = await owsAccountFromWalletId(wallet.owsWalletId);
-            return account.address;
+            const { getOwsWalletAddress } = await import("./ows-adapter.js");
+            return await getOwsWalletAddress(wallet.owsWalletId, chain === "solana" ? "solana" : "evm");
         }
         catch {
             return null;
         }
     }
+    if (chain === "solana") {
+        return null;
+    }
     // Raw EVM key path
     if (!wallet.key)
         return null;

package/dist/core/principal.d.ts

@@ -0,0 +1,2 @@
+export declare function getConsumerPrincipal(): Promise<string | null>;
+export declare function ensureConsumerPrincipal(): Promise<string>;

package/dist/core/principal.js

@@ -0,0 +1,109 @@
+import { addWallet, getDefaultWallet, getWallets } from "./config.js";
+import { getWalletAddress } from "./payments.js";
+import { createOwsWallet, isOwsAvailable, listOwsWallets, } from "./ows-adapter.js";
+const BASE_CHAIN_ID = "8453";
+const SOLANA_CHAIN_ID = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+const AUTO_IDENTITY_LABEL = "AW Identity";
+function principalFromAddress(address, type) {
+    if (type === "evm") {
+        return `did:pkh:eip155:${BASE_CHAIN_ID}:${address.toLowerCase()}`;
+    }
+    return `did:pkh:${SOLANA_CHAIN_ID}:${address}`;
+}
+function walletSupportsEvm(wallet) {
+    return wallet.chains.some((chain) => chain !== "solana");
+}
+function walletSupportsSolana(wallet) {
+    return wallet.chains.includes("solana");
+}
+async function walletPrincipal(wallet) {
+    if (walletSupportsEvm(wallet)) {
+        const address = await getWalletAddress(wallet.id);
+        return address ? principalFromAddress(address, "evm") : null;
+    }
+    if (walletSupportsSolana(wallet)) {
+        const address = await getWalletAddress(wallet.id);
+        return address ? principalFromAddress(address, "solana") : null;
+    }
+    return null;
+}
+function preferredWallets() {
+    const wallets = getWallets();
+    const defaultWallet = getDefaultWallet();
+    const ordered = defaultWallet
+        ? [defaultWallet, ...wallets.filter((wallet) => wallet.id !== defaultWallet.id)]
+        : wallets;
+    return ordered.sort((a, b) => {
+        const aScore = walletSupportsEvm(a) ? 0 : walletSupportsSolana(a) ? 1 : 2;
+        const bScore = walletSupportsEvm(b) ? 0 : walletSupportsSolana(b) ? 1 : 2;
+        return aScore - bScore;
+    });
+}
+async function createFallbackIdentityWallet() {
+    const { generatePrivateKey } = await import("viem/accounts");
+    const walletName = `aw-identity-${Date.now()}`;
+    const entry = {
+        id: walletName,
+        keyType: "evm",
+        key: generatePrivateKey(),
+        chains: ["tempo", "base"],
+        defaultChain: "base",
+        label: AUTO_IDENTITY_LABEL,
+    };
+    addWallet(entry);
+    return entry;
+}
+async function ensureIdentityWallet() {
+    const wallets = preferredWallets();
+    const existing = wallets.find((wallet) => walletSupportsEvm(wallet) || walletSupportsSolana(wallet));
+    if (existing)
+        return existing;
+    if (await isOwsAvailable()) {
+        const existingOwsWallets = await listOwsWallets();
+        const linked = existingOwsWallets[0];
+        if (linked) {
+            const entry = {
+                id: linked.name,
+                keyType: "ows",
+                owsWalletId: linked.id,
+                chains: ["tempo", "base"],
+                defaultChain: "base",
+                label: linked.name,
+            };
+            addWallet(entry);
+            return entry;
+        }
+        const walletName = `aw-identity-${Date.now()}`;
+        const created = await createOwsWallet(walletName, "evm");
+        const entry = {
+            id: walletName,
+            keyType: "ows",
+            owsWalletId: created.walletId,
+            chains: ["tempo", "base"],
+            defaultChain: "base",
+            label: AUTO_IDENTITY_LABEL,
+        };
+        addWallet(entry);
+        return entry;
+    }
+    return createFallbackIdentityWallet();
+}
+export async function getConsumerPrincipal() {
+    for (const wallet of preferredWallets()) {
+        const principal = await walletPrincipal(wallet);
+        if (principal)
+            return principal;
+    }
+    return null;
+}
+export async function ensureConsumerPrincipal() {
+    const existing = await getConsumerPrincipal();
+    if (existing)
+        return existing;
+    const identityWallet = await ensureIdentityWallet();
+    const principal = await walletPrincipal(identityWallet);
+    if (!principal) {
+        throw new Error("Could not derive a consumer principal from the configured identity wallet.");
+    }
+    return principal;
+}

package/dist/core/solana-charge.d.ts

@@ -0,0 +1,9 @@
+import type { WalletEntry } from "./config.js";
+export declare const SOLANA_USDC_MINT: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+export declare const SOLANA_CHAIN_ID: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+interface SolanaChargeClientConfig {
+    wallet: WalletEntry;
+    rpcUrl?: string;
+}
+export declare function solanaChargeClient(config: SolanaChargeClientConfig): any;
+export {};

package/dist/core/solana-charge.js

@@ -0,0 +1,96 @@
+/**
+ * Custom MPP payment method: Solana USDC charge (client-side).
+ *
+ * Sends an SPL Token transfer on Solana mainnet and returns the transaction
+ * signature as the payment credential.
+ */
+import { Credential, Method, z } from "mppx";
+import { Connection, Keypair, PublicKey, Transaction, sendAndConfirmTransaction } from "@solana/web3.js";
+import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID, createTransferCheckedInstruction, getAssociatedTokenAddressSync, } from "@solana/spl-token";
+import { toAtomicAmount } from "./amount-utils.js";
+export const SOLANA_USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+export const SOLANA_CHAIN_ID = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+const SOLANA_RPC = "https://api.mainnet-beta.solana.com";
+const solanaChargeMethod = Method.from({
+    name: "solana",
+    intent: "charge",
+    schema: {
+        credential: {
+            payload: z.object({
+                signature: z.string(),
+                type: z.literal("signature"),
+            }),
+        },
+        request: z.pipe(z.object({
+            amount: z.string(),
+            currency: z.string(),
+            recipient: z.string(),
+            chainId: z.optional(z.string()),
+            decimals: z.optional(z.number()),
+        }), z.transform((value) => ({
+            ...value,
+            methodDetails: { chainId: value.chainId ?? SOLANA_CHAIN_ID },
+        }))),
+    },
+});
+function keypairFromPrivateKeyHex(privateKeyHex) {
+    const normalized = privateKeyHex.startsWith("0x")
+        ? privateKeyHex.slice(2)
+        : privateKeyHex;
+    const bytes = Uint8Array.from(Buffer.from(normalized, "hex"));
+    if (bytes.length === 32) {
+        return Keypair.fromSeed(bytes);
+    }
+    if (bytes.length === 64) {
+        return Keypair.fromSecretKey(bytes);
+    }
+    throw new Error(`Unsupported Solana private key length: ${bytes.length} bytes.`);
+}
+async function getKeypair(wallet) {
+    if (wallet.keyType === "ows" && wallet.owsWalletId) {
+        const { owsSolanaKeypairFromWalletId } = await import("./ows-adapter.js");
+        return owsSolanaKeypairFromWalletId(wallet.owsWalletId);
+    }
+    if (wallet.key) {
+        return keypairFromPrivateKeyHex(wallet.key);
+    }
+    throw new Error(`Wallet "${wallet.id}" cannot sign Solana transactions.`);
+}
+async function resolveRecipientTokenAccount(connection, mint, recipient) {
+    const accountInfo = await connection.getParsedAccountInfo(recipient, "confirmed");
+    const owner = accountInfo.value?.owner;
+    if (owner && owner.toBase58() === TOKEN_PROGRAM_ID.toBase58()) {
+        return recipient;
+    }
+    return getAssociatedTokenAddressSync(mint, recipient, false, TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID);
+}
+export function solanaChargeClient(config) {
+    return Method.toClient(solanaChargeMethod, {
+        async createCredential({ challenge }) {
+            const { request } = challenge;
+            const amount = toAtomicAmount(request.amount, request.decimals ?? 6);
+            const decimals = request.decimals ?? 6;
+            const mint = new PublicKey(request.currency ?? SOLANA_USDC_MINT);
+            const recipient = new PublicKey(request.recipient);
+            const keypair = await getKeypair(config.wallet);
+            const owner = keypair.publicKey;
+            const connection = new Connection(config.rpcUrl ?? SOLANA_RPC, "confirmed");
+            const sourceTokenAccount = getAssociatedTokenAddressSync(mint, owner, false, TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID);
+            const destinationTokenAccount = await resolveRecipientTokenAccount(connection, mint, recipient);
+            const instruction = createTransferCheckedInstruction(sourceTokenAccount, mint, destinationTokenAccount, owner, amount, decimals);
+            const { blockhash } = await connection.getLatestBlockhash("confirmed");
+            const transaction = new Transaction({
+                feePayer: owner,
+                recentBlockhash: blockhash,
+            }).add(instruction);
+            const signature = await sendAndConfirmTransaction(connection, transaction, [keypair], {
+                commitment: "confirmed",
+            });
+            return Credential.serialize({
+                challenge,
+                payload: { signature, type: "signature" },
+                source: `did:pkh:${SOLANA_CHAIN_ID}:${owner.toBase58()}`,
+            });
+        },
+    });
+}

package/dist/core/spend-policy.d.ts

@@ -0,0 +1,12 @@
+export declare function getDailySpend(method: string, now?: Date): number;
+export declare function canSpend(params: {
+    method: string;
+    amountUsd: number;
+}): {
+    ok: true;
+} | {
+    ok: false;
+    message: string;
+};
+export declare function requiresPolicyConfirmation(method: string, amountUsd: number): boolean;
+export declare function recordSpend(method: string, amountUsd: number, now?: Date): void;

package/dist/core/spend-policy.js

@@ -0,0 +1,53 @@
+import { getSpendLedger, getSpendPolicy, saveSpendLedger, } from "./config.js";
+const LEDGER_RETENTION_DAYS = 35;
+function utcDay(now) {
+    return now.toISOString().slice(0, 10);
+}
+function pruneLedger(entries, now) {
+    const cutoff = new Date(now);
+    cutoff.setUTCDate(cutoff.getUTCDate() - LEDGER_RETENTION_DAYS);
+    return entries.filter((entry) => new Date(entry.timestamp) >= cutoff);
+}
+export function getDailySpend(method, now = new Date()) {
+    const day = utcDay(now);
+    return getSpendLedger()
+        .filter((entry) => entry.method === method && entry.day === day)
+        .reduce((sum, entry) => sum + entry.amountUsd, 0);
+}
+export function canSpend(params) {
+    const policy = getSpendPolicy(params.method);
+    if (!policy)
+        return { ok: true };
+    if (policy.maxPerTxUsd != null && params.amountUsd > policy.maxPerTxUsd) {
+        return {
+            ok: false,
+            message: `Transaction blocked by spend policy: $${params.amountUsd.toFixed(2)} exceeds max_per_tx of $${policy.maxPerTxUsd.toFixed(2)} for "${params.method}".`,
+        };
+    }
+    if (policy.maxPerDayUsd != null) {
+        const spentToday = getDailySpend(params.method);
+        if (spentToday + params.amountUsd > policy.maxPerDayUsd) {
+            return {
+                ok: false,
+                message: `Transaction blocked by spend policy: daily spend would be $${(spentToday + params.amountUsd).toFixed(2)} > $${policy.maxPerDayUsd.toFixed(2)} for "${params.method}".`,
+            };
+        }
+    }
+    return { ok: true };
+}
+export function requiresPolicyConfirmation(method, amountUsd) {
+    const policy = getSpendPolicy(method);
+    if (!policy?.requireConfirmationAboveUsd)
+        return false;
+    return amountUsd >= policy.requireConfirmationAboveUsd;
+}
+export function recordSpend(method, amountUsd, now = new Date()) {
+    const entries = pruneLedger(getSpendLedger(), now);
+    entries.push({
+        method,
+        amountUsd,
+        day: utcDay(now),
+        timestamp: now.toISOString(),
+    });
+    saveSpendLedger(entries);
+}

package/dist/core/types.d.ts

@@ -5,8 +5,7 @@ export interface AgentRecord {
     id: string;
     name: string;
     description?: string;
-    pricePer1kTokens?: string;
-    pricingModel?: string;
+    pricePerRunUsd?: string;
     avgRating?: number | null;
     totalExecutions?: number;
     successRate?: number | string | null;
@@ -21,6 +20,16 @@ export interface AgentRecord {
     };
     payment?: {
         pricing?: Record<string, unknown>;
+        accepted_payments?: string[];
+        credit_packs?: {
+            unit_type?: string;
+            packs?: Array<{
+                key?: string;
+                name?: string;
+                included_units?: number;
+                price_usd?: string;
+            }>;
+        } | null;
         [key: string]: unknown;
     };
     [key: string]: unknown;

package/dist/index.js

@@ -11,6 +11,8 @@ import { registerRateTools } from "./tools/rate.js";
 import { registerWalletTools } from "./tools/wallet.js";
 import { registerFavoriteTools } from "./tools/favorites.js";
 import { registerTipTools } from "./tools/tip.js";
+import { registerPassTools } from "./tools/passes.js";
+import { registerObservabilityTools } from "./tools/observability.js";
 // ── Resources ────────────────────────────────────────────────────
 import { registerAgentResources } from "./resources/agents.js";
 import { registerWalletResources } from "./resources/wallet.js";
@@ -33,14 +35,18 @@ export async function startMcpServer() {
             "1. search_agents() or solve() — find agents for the task",
             "2. get_agent() — check required input fields before running",
             "3. run_agent() or solve() with ALL required fields",
-            "4. If no payment method is set up, run_agent returns a QR code to connect a credit card — present it to the user",
+            "3a. If the agent offers discounted credit packs, use buy_agent_credit_pack() and list_agent_credit_packs() when helpful",
+            "4. If no payment method is set up, run_agent returns a setup page to connect a credit card — present it to the user",
             "5. Ask user to rate or tip after a successful run",
             "",
             "PAYMENT:",
-            "- Credit/debit card is the default and easiest way to pay — scan a QR code to connect, no funding needed.",
-            "- Crypto wallets (Tempo USDC, Base USDC) are available for advanced users.",
+            "- Credit/debit card is the default and easiest way to pay — open the setup page to connect, no funding needed.",
+            "- Crypto wallets (Tempo USDC, Base USDC, Solana USDC) are available for advanced users.",
             "- Card and crypto are SEPARATE payment methods. Card charges a credit card; crypto sends USDC on-chain.",
             "- Card is set as the default payment method when configured.",
+            "- run_agent() and solve() require pay_with explicitly.",
+            "- Use wallet_status to see the exact payment methods the user has configured before calling a paid tool.",
+            "- Use open_observability_dashboard() to open a secure web usage dashboard for runs/spend/rebates.",
             "- Payment is automatic once configured. Users are never charged for failed runs.",
             "- Do NOT ask the user to set up payment before they try to run an agent. Let them explore freely.",
             "- If a specific payment method fails, report the error clearly. Do NOT silently fall back to a different method.",
@@ -65,6 +71,8 @@ export async function startMcpServer() {
     registerWalletTools(server);
     registerFavoriteTools(server);
     registerTipTools(server);
+    registerPassTools(server);
+    registerObservabilityTools(server);
     // Register resources
     registerAgentResources(server);
     registerWalletResources(server);

package/dist/prompts/index.js

@@ -12,7 +12,7 @@ export function registerPrompts(server) {
                         "1. Check my wallet status with wallet_status",
                         "2. If no wallet is configured, help me create one with wallet_setup",
                         "3. Show me some popular agents with search_agents",
-                        "4. Briefly explain how solve, run_agent, rating, and tipping work",
+                        "4. Briefly explain how solve, run_agent, buy_agent_credit_pack, pay_with selection, rating, and tipping work",
                     ].join("\n"),
                 },
             }],
@@ -62,7 +62,7 @@ export function registerPrompts(server) {
                     text: [
                         `Complete this task on Agent Wonderland within $${budget || "1.00"}: "${task}"`,
                         "",
-                        "Use the solve tool with the budget parameter. Show me what agent was selected and why.",
+                        "Use the solve tool with the budget parameter and an explicit pay_with method. Show me what agent was selected and why.",
                     ].join("\n"),
                 },
             }],
@@ -78,6 +78,8 @@ export function registerPrompts(server) {
                     text: [
                         `Run agent ${agent_id} with this input: ${input}`,
                         "",
+                        "Include an explicit pay_with method when you call run_agent.",
+                        "",
                         "After getting the result:",
                         "1. Summarize the output",
                         "2. Assess the quality",

package/dist/resources/agents.js

@@ -7,7 +7,7 @@ export function registerAgentResources(server) {
         const lines = agents.map(a => {
             const rating = stars(a.reputationScore);
             const jobs = compactNumber(a.totalExecutions);
-            const price = formatPrice(a.pricePer1kTokens);
+            const price = formatPrice(a.pricePerRunUsd);
             return `${a.name} ${rating} ${jobs} jobs | ${price}/req — ${a.description || ""}`;
         });
         return {

package/dist/resources/wallet.js

@@ -1,9 +1,11 @@
-import { getWallets, getCardConfig } from "../core/config.js";
+import { getWallets, getCardConfig, getPendingCardSetupToken } from "../core/config.js";
+import { getCardCapabilities } from "../core/card-setup.js";
 import { getWalletAddress, getConfiguredMethods } from "../core/payments.js";
 export function registerWalletResources(server) {
     server.resource("wallet-config", "aw://wallet", async () => {
         const wallets = getWallets();
         const card = getCardConfig();
+        const pendingCardSetupToken = getPendingCardSetupToken();
         const methods = getConfiguredMethods();
         const lines = ["Wallet Configuration", ""];
         for (const w of wallets) {
@@ -13,6 +15,11 @@ export function registerWalletResources(server) {
         }
         if (card) {
             lines.push(`Card: ${card.brand} ****${card.last4}`);
+            const capabilities = await getCardCapabilities();
+            lines.push(`Card MPP: ${capabilities.spt_status}${capabilities.message ? ` — ${capabilities.message}` : ""}`);
+        }
+        if (pendingCardSetupToken) {
+            lines.push("Card setup: pending confirmation");
         }
         lines.push("", `Configured methods: ${methods.join(", ") || "none"}`);
         return {

package/dist/tools/__tests__/_payment-confirmation.test.d.ts

@@ -0,0 +1 @@
+export {};