@agentwonderland/mcp 0.1.25 → 0.1.26

package/dist/tools/__tests__/wallet.test.js

@@ -0,0 +1,230 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+const state = vi.hoisted(() => ({
+    wallets: [],
+    addedWallets: [],
+    card: null,
+    pendingCardSetupToken: null,
+    spendPolicies: {},
+    consumerPrincipal: "did:pkh:eip155:8453:0xabc",
+    owsAvailable: true,
+    owsWallets: [],
+    owsWalletsByChain: [],
+    createdWalletCalls: [],
+    importWalletCalls: [],
+    createdWalletResult: {
+        walletId: "ows-wallet-created",
+        address: "0x1111111111111111111111111111111111111111",
+    },
+    importWalletResult: {
+        walletId: "ows-wallet-imported",
+        address: "0x2222222222222222222222222222222222222222",
+    },
+    cardSetup: {
+        url: "https://api.agentwonderland.com/card/handoff/setup-token",
+        token: "setup-token",
+        isNew: true,
+    },
+    cardSetupBlocks: [
+        "Open this setup page to connect your card:\n\nhttps://api.agentwonderland.com/card/handoff/setup-token",
+    ],
+    pollCardSetupCalls: [],
+    pollCardSetupResult: null,
+    setCardConfigCalls: [],
+}));
+vi.mock("../../core/config.js", () => ({
+    addWallet: (wallet) => {
+        state.addedWallets.push(wallet);
+        const existing = state.wallets.findIndex((entry) => entry.id === wallet.id);
+        if (existing >= 0) {
+            state.wallets[existing] = wallet;
+        }
+        else {
+            state.wallets.push(wallet);
+        }
+    },
+    getCardConfig: () => state.card,
+    getPendingCardSetupToken: () => state.pendingCardSetupToken,
+    getSpendPolicy: (walletId) => state.spendPolicies[walletId] ?? null,
+    getWallets: () => state.wallets,
+    setCardConfig: (card) => {
+        state.card = card;
+        state.setCardConfigCalls.push(card);
+    },
+    setSpendPolicy: (walletId, policy) => {
+        state.spendPolicies[walletId] = policy;
+    },
+}));
+vi.mock("../../core/payments.js", () => ({
+    getWalletAddress: async () => null,
+}));
+vi.mock("../../core/card-setup.js", () => ({
+    formatCardSetupBlocks: () => state.cardSetupBlocks,
+    getCardCapabilities: async () => ({
+        spt_status: "enabled",
+    }),
+    getOrCreatePendingCardSetup: async () => state.cardSetup,
+    pollCardSetup: async (token, timeoutMs) => {
+        state.pollCardSetupCalls.push({ token, timeoutMs });
+        return state.pollCardSetupResult;
+    },
+}));
+vi.mock("../../core/ows-adapter.js", () => ({
+    createOwsWallet: async (name, chain) => {
+        state.createdWalletCalls.push({ name, chain });
+        return state.createdWalletResult;
+    },
+    importKeyToOws: async (privateKey, name, chain) => {
+        state.importWalletCalls.push({ privateKey, name, chain });
+        return state.importWalletResult;
+    },
+    isOwsAvailable: async () => state.owsAvailable,
+    listOwsWallets: async () => state.owsWallets,
+    listOwsWalletsByChain: async () => state.owsWalletsByChain,
+}));
+vi.mock("../../core/principal.js", () => ({
+    ensureConsumerPrincipal: async () => state.consumerPrincipal,
+    getConsumerPrincipal: async () => state.consumerPrincipal,
+}));
+function resetState() {
+    state.wallets = [];
+    state.addedWallets = [];
+    state.card = null;
+    state.pendingCardSetupToken = null;
+    state.spendPolicies = {};
+    state.consumerPrincipal = "did:pkh:eip155:8453:0xabc";
+    state.owsAvailable = true;
+    state.owsWallets = [];
+    state.owsWalletsByChain = [];
+    state.createdWalletCalls = [];
+    state.importWalletCalls = [];
+    state.createdWalletResult = {
+        walletId: "ows-wallet-created",
+        address: "0x1111111111111111111111111111111111111111",
+    };
+    state.importWalletResult = {
+        walletId: "ows-wallet-imported",
+        address: "0x2222222222222222222222222222222222222222",
+    };
+    state.cardSetup = {
+        url: "https://api.agentwonderland.com/card/handoff/setup-token",
+        token: "setup-token",
+        isNew: true,
+    };
+    state.cardSetupBlocks = [
+        "Open this setup page to connect your card:\n\nhttps://api.agentwonderland.com/card/handoff/setup-token",
+    ];
+    state.pollCardSetupCalls = [];
+    state.pollCardSetupResult = null;
+    state.setCardConfigCalls = [];
+}
+async function getWalletSetupTool() {
+    const tools = new Map();
+    const server = {
+        tool: (name, _description, _schema, handler) => {
+            tools.set(name, handler);
+        },
+    };
+    const { registerWalletTools } = await import("../wallet.js");
+    registerWalletTools(server);
+    const walletSetup = tools.get("wallet_setup");
+    if (!walletSetup) {
+        throw new Error("wallet_setup tool was not registered");
+    }
+    return walletSetup;
+}
+function flattenText(result) {
+    return result.content.map((item) => item.text).join("\n");
+}
+describe("wallet_setup tool", () => {
+    beforeEach(() => {
+        vi.resetModules();
+        resetState();
+    });
+    it("creates an encrypted OWS wallet for Tempo/Base with Base as the default chain", async () => {
+        const walletSetup = await getWalletSetupTool();
+        const result = await walletSetup({ action: "create", name: "launch-wallet", chain: "base" });
+        const text = flattenText(result);
+        expect(state.createdWalletCalls).toEqual([
+            { name: "launch-wallet", chain: "evm" },
+        ]);
+        expect(state.addedWallets).toEqual([
+            {
+                id: "launch-wallet",
+                keyType: "ows",
+                owsWalletId: "ows-wallet-created",
+                chains: ["tempo", "base"],
+                defaultChain: "base",
+                label: "launch-wallet",
+            },
+        ]);
+        expect(text).toContain("Wallet created [encrypted]:");
+        expect(text).toContain("Address: 0x1111111111111111111111111111111111111111");
+        expect(text).toContain("Chains: tempo, base");
+        expect(text).toContain("Consumer principal: did:pkh:eip155:8453:0xabc");
+    });
+    it("imports a wallet into OWS encrypted storage with Base as the default chain", async () => {
+        const walletSetup = await getWalletSetupTool();
+        const result = await walletSetup({
+            action: "import",
+            key: "0x1234",
+            name: "imported-wallet",
+            chain: "base",
+        });
+        const text = flattenText(result);
+        expect(state.importWalletCalls).toEqual([
+            { privateKey: "0x1234", name: "imported-wallet", chain: "evm" },
+        ]);
+        expect(state.addedWallets).toEqual([
+            {
+                id: "imported-wallet",
+                keyType: "ows",
+                owsWalletId: "ows-wallet-imported",
+                chains: ["tempo", "base"],
+                defaultChain: "base",
+                label: "imported-wallet",
+            },
+        ]);
+        expect(text).toContain("Key imported to OWS [encrypted]:");
+        expect(text).toContain("Address: 0x2222222222222222222222222222222222222222");
+        expect(text).toContain("Consumer principal: did:pkh:eip155:8453:0xabc");
+    });
+    it("starts card setup when no card is connected", async () => {
+        const walletSetup = await getWalletSetupTool();
+        const result = await walletSetup({ action: "add-card" });
+        const text = flattenText(result);
+        expect(text).toContain("Open this setup page to connect your card:");
+        expect(text).toContain("https://api.agentwonderland.com/card/handoff/setup-token");
+        expect(state.pollCardSetupCalls).toEqual([]);
+    });
+    it("completes a pending card setup when Stripe handoff has finished", async () => {
+        state.pendingCardSetupToken = "setup-token";
+        state.pollCardSetupResult = {
+            brand: "Visa",
+            last4: "4242",
+            consumerToken: "consumer-token",
+        };
+        const walletSetup = await getWalletSetupTool();
+        const result = await walletSetup({ action: "add-card" });
+        const text = flattenText(result);
+        expect(state.pollCardSetupCalls).toEqual([
+            { token: "setup-token", timeoutMs: 250 },
+        ]);
+        expect(text).toContain("Connected! Visa ****4242 is ready for payments.");
+        expect(text).toContain("Consumer principal: did:pkh:eip155:8453:0xabc");
+    });
+    it("removes the connected card", async () => {
+        state.card = {
+            consumerToken: "consumer-token",
+            paymentMethodId: "pm_123",
+            last4: "4242",
+            brand: "Visa",
+        };
+        const walletSetup = await getWalletSetupTool();
+        const result = await walletSetup({ action: "remove-card" });
+        const text = flattenText(result);
+        expect(state.setCardConfigCalls).toEqual([null]);
+        expect(state.card).toBeNull();
+        expect(text).toContain("Removed Visa ****4242.");
+        expect(text).toContain("Card disconnected from Agent Wonderland.");
+    });
+});

package/dist/tools/_payment-confirmation.js

@@ -23,6 +23,6 @@ export function formatPaymentChoicePrompt(subject, methods, commands) {
         ...commands,
         "",
         `Available methods: ${methods.map((method) => `"${method}"`).join(", ")}`,
-        "For fully agentic execution, include pay_with explicitly.",
+        "You can omit pay_with to use the default compatible method.",
     ].join("\n");
 }

package/dist/tools/jobs.js

@@ -11,7 +11,14 @@ export function registerJobTools(server) {
     server.tool("get_job", "Get the status and output of a job by ID. Use to poll async jobs until they complete.", {
         job_id: z.string().describe("Job ID (UUID)"),
     }, async ({ job_id }) => {
-        const result = await apiGet(`/jobs/${job_id}`);
+        let url = `/jobs/${job_id}`;
+        if (!isAuthenticated() && hasWalletConfigured()) {
+            const address = await getWalletAddress();
+            if (address) {
+                url += `?wallet=${encodeURIComponent(address)}`;
+            }
+        }
+        const result = await apiGet(url);
         if (result.status === "processing") {
             return text(`Job ${job_id} is still processing...`);
         }

package/dist/tools/passes.js

@@ -1,9 +1,9 @@
 import { z } from "zod";
 import { apiGet, apiPostWithPayment } from "../core/api-client.js";
-import { formatCreditPack, formatCreditPackOffer, getCreditPackProgram, } from "../core/passes.js";
+import { formatCreditPack, formatCreditPackOffer, getCreditPackInventory, getCreditPackProgram, } from "../core/passes.js";
 import { getCompatiblePaymentMethods, getConfiguredMethods, hasWalletConfigured, normalizePaymentMethod, } from "../core/payments.js";
 import { requiresSpendConfirmation } from "../core/config.js";
-import { ensureConsumerPrincipal } from "../core/principal.js";
+import { ensureConsumerPrincipalForMethod } from "../core/principal.js";
 import { getOrCreatePendingCardSetup, formatCardSetupBlocks } from "../core/card-setup.js";
 import { formatPaymentChoicePrompt, formatPaymentLabel, resolveConfirmationMethod, } from "./_payment-confirmation.js";
 const pendingCreditPackPurchases = new Map();
@@ -51,7 +51,6 @@ export function registerPassTools(server) {
         }
         const agent = await getAgent(agent_id);
         const agentName = agent.name ?? agent_id;
-        const principal = await ensureConsumerPrincipal();
         const program = getCreditPackProgram(agent);
         const offers = (program?.packs ?? [])
             .map((pack) => findOffer(agent, pack.key ?? ""))
@@ -102,6 +101,7 @@ export function registerPassTools(server) {
             ].join("\n"));
         }
         const method = resolveConfirmationMethod(pay_with, pending?.method, compatibleMethods);
+        const principal = await ensureConsumerPrincipalForMethod(method);
         if (requiresSpendConfirmation() && !confirmed) {
             pendingCreditPackPurchases.set(agent.id, {
                 agentId: agent.id,
@@ -131,14 +131,19 @@ export function registerPassTools(server) {
             formatCreditPack(result.credit_pack),
             `Consumer principal: ${result.consumer_principal}`,
             "",
-            "Future runs through run_agent will automatically use this credit pack while units remain.",
+            "Future runs for this agent will automatically use this credit pack while units remain.",
+            "That includes run_agent, and solve whenever it selects this same agent.",
         ].join("\n"));
     });
     server.tool("list_agent_credit_packs", "Show discounted credit-pack offers for an agent plus any balances available under the current consumer principal.", {
         agent_id: z.string().describe("Agent ID (UUID, slug, or name)"),
-    }, async ({ agent_id }) => {
+        pay_with: z.string().optional().describe("Optional payment method context used to inspect the matching consumer principal."),
+    }, async ({ agent_id, pay_with }) => {
         const agent = await getAgent(agent_id);
-        const result = await apiGet(`/agents/${agent.id}/credit-packs`, { ensureConsumerPrincipal: true });
+        const result = await getCreditPackInventory(agent.id, pay_with);
+        if (!result) {
+            return text(`Could not load credit-pack inventory for ${agent.name}.`);
+        }
         const lines = [
             `Credit packs for ${agent.name}`,
             ...(result.consumer_principal ? [`Consumer principal: ${result.consumer_principal}`] : []),

package/dist/tools/run.js

@@ -11,9 +11,9 @@ import { getOrCreatePendingCardSetup, formatCardSetupBlocks } from "../core/card
 import { formatPaymentLabel, formatRunConfirmationCommand, resolveConfirmationMethod, } from "./_payment-confirmation.js";
 const POLL_INTERVAL_MS = 3000;
 const POLL_MAX_MS = 120000;
-async function pollJobUntilDone(jobId) {
+async function pollJobUntilDone(jobId, paymentMethod) {
     const deadline = Date.now() + POLL_MAX_MS;
-    const walletAddress = await getWalletAddress();
+    const walletAddress = await getWalletAddress(paymentMethod);
     const walletParam = walletAddress ? `?wallet=${walletAddress}` : "";
     while (Date.now() < deadline) {
         await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
@@ -61,7 +61,7 @@ export function registerRunTools(server) {
     server.tool("run_agent", "Run an AI agent from the marketplace. Pays automatically via configured wallet. Returns the agent's output, cost, and job ID for tracking. If spending confirmation is enabled, first call returns a price quote — call again with confirmed: true to execute. Local file paths in the input (e.g. /Users/.../photo.jpg) are automatically uploaded to temporary storage and replaced with download URLs before execution.", {
         agent_id: z.string().describe("Agent ID (UUID, slug, or name)"),
         input: z.record(z.unknown()).describe("Input payload for the agent"),
-        pay_with: z.string().trim().min(1).describe("Required payment method — wallet ID, chain name (tempo, base, etc.), or 'card'. Use wallet_status to see configured options."),
+        pay_with: z.string().trim().min(1).optional().describe("Payment method — wallet ID, chain name (tempo, base, etc.), or 'card'. Auto-detected if omitted."),
         confirmed: z.boolean().optional().describe("Set to true to confirm spending after seeing the price quote."),
     }, async ({ agent_id, input, pay_with, confirmed }) => {
         if (!hasWalletConfigured()) {
@@ -84,23 +84,27 @@ export function registerRunTools(server) {
         }
         const price = parseFloat(agent.pricePerRunUsd ?? "0.01");
         const agentName = agent.name ?? agent_id;
-        const creditPackInventory = await getCreditPackInventory(agent.id);
-        const activeCreditPack = getActiveCreditPack(creditPackInventory);
         const compatibleMethods = getCompatiblePaymentMethods(agent, getConfiguredMethods());
         const pending = pendingRuns.get(agent.id);
-        const requestedMethod = pay_with;
-        const normalizedRequestedMethod = normalizePaymentMethod(requestedMethod);
-        if (!normalizedRequestedMethod) {
+        const requestedMethod = pay_with ?? pending?.method;
+        const normalizedRequestedMethod = requestedMethod ? normalizePaymentMethod(requestedMethod) : null;
+        const creditPackInventory = await getCreditPackInventory(agent.id, requestedMethod);
+        const activeCreditPack = getActiveCreditPack(creditPackInventory);
+        if (requestedMethod && !normalizedRequestedMethod) {
             return text(`Payment method "${requestedMethod}" is not configured.\n\n` +
                 "Use wallet_status to review your current payment methods.");
         }
-        if (!compatibleMethods.includes(normalizedRequestedMethod)) {
+        if (normalizedRequestedMethod && !compatibleMethods.includes(normalizedRequestedMethod)) {
             return text(`This agent cannot be paid with "${requestedMethod}".\n\n` +
                 `Available payment methods for this agent: ${compatibleMethods.join(", ") || "none"}.\n` +
                 "Use get_agent to inspect the agent details or choose another payment method.");
         }
-        const method = resolveConfirmationMethod(pay_with, pending?.method, compatibleMethods);
-        const spendCheckMethod = method ?? normalizedRequestedMethod;
+        if (!activeCreditPack && compatibleMethods.length === 0) {
+            return text(`No compatible payment methods are configured for ${agentName}.\n\n` +
+                "Use wallet_status to review your current payment methods.");
+        }
+        const method = resolveConfirmationMethod(requestedMethod, pending?.method, compatibleMethods);
+        const spendCheckMethod = method ?? normalizedRequestedMethod ?? compatibleMethods[0];
         if (!activeCreditPack) {
             const spendCheck = canSpend({
                 method: spendCheckMethod,
@@ -201,7 +205,7 @@ export function registerRunTools(server) {
         const status = result.status;
         const usedCreditPack = result.consumption_mode === "credit_pack";
         if (status === "processing") {
-            const pollResult = await pollJobUntilDone(jobId);
+            const pollResult = await pollJobUntilDone(jobId, method);
             if (pollResult.status === "completed") {
                 const asyncFormatted = formatRunResult({
                     ...result,

package/dist/tools/solve.js

@@ -11,9 +11,9 @@ import { formatPaymentLabel, formatSolveConfirmationCommand, makeSolvePendingKey
 import { getActiveCreditPack, getCreditPackInventory, getCreditPackProgram } from "../core/passes.js";
 const POLL_INTERVAL_MS = 3000;
 const POLL_MAX_MS = 120000;
-async function pollSolveJob(jobId) {
+async function pollSolveJob(jobId, paymentMethod) {
     const deadline = Date.now() + POLL_MAX_MS;
-    const walletAddress = await getWalletAddress();
+    const walletAddress = await getWalletAddress(paymentMethod);
     const walletParam = walletAddress ? `?wallet=${walletAddress}` : "";
     while (Date.now() < deadline) {
         await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
@@ -106,7 +106,8 @@ export function registerSolveTools(server) {
             .string()
             .trim()
             .min(1)
-            .describe("Required payment method — wallet ID, chain name (tempo, base, etc.), or 'card'. Use wallet_status to see configured options."),
+            .optional()
+            .describe("Payment method — wallet ID, chain name (tempo, base, etc.), or 'card'. Auto-detected if omitted."),
         confirmed: z
             .boolean()
             .optional()
@@ -126,9 +127,9 @@ export function registerSolveTools(server) {
         const pendingKey = makeSolvePendingKey(intent, input, budget);
         const pending = pendingSolves.get(pendingKey);
         const configuredMethods = getConfiguredMethods();
-        const requestedMethod = pay_with;
-        const normalizedRequestedMethod = normalizePaymentMethod(requestedMethod);
-        if (!normalizedRequestedMethod) {
+        const requestedMethod = pay_with ?? pending?.method;
+        const normalizedRequestedMethod = requestedMethod ? normalizePaymentMethod(requestedMethod) : null;
+        if (requestedMethod && !normalizedRequestedMethod) {
             return text(`Payment method "${requestedMethod}" is not configured.\n\n` +
                 "Use wallet_status to review your current payment methods.");
         }
@@ -159,10 +160,12 @@ export function registerSolveTools(server) {
             return multiText(formatRunResult(result), feedbackAsk(jobId, agentId, usedCreditPack ? undefined : cost, tipMsg));
         }
         catch (err) {
-            const isAuthError = err instanceof Error &&
-                "status" in err &&
-                err.status === 401;
-            if (!isAuthError || !hasWalletConfigured())
+            const status = err instanceof Error &&
+                "status" in err
+                ? err.status
+                : undefined;
+            const isRecoverableDirectSolveError = status === 401 || status === 402;
+            if (!isRecoverableDirectSolveError || !hasWalletConfigured())
                 throw err;
         }
         const params = new URLSearchParams({ q: intent, limit: "5" });
@@ -182,15 +185,19 @@ export function registerSolveTools(server) {
             return price <= budget;
         });
         const selected = affordable[0] ?? agents[0];
-        const activeCreditPack = await getCreditPackInventory(selected.id).then(getActiveCreditPack);
+        const activeCreditPack = await getCreditPackInventory(selected.id, requestedMethod).then(getActiveCreditPack);
         const compatibleMethods = getCompatiblePaymentMethods(selected, configuredMethods);
-        if (!compatibleMethods.includes(normalizedRequestedMethod)) {
+        if (normalizedRequestedMethod && !compatibleMethods.includes(normalizedRequestedMethod)) {
             return text(`The best matching agent cannot be paid with "${requestedMethod}".\n\n` +
                 `Available payment methods for ${selected.name}: ${compatibleMethods.join(", ") || "none"}.\n` +
                 "Choose another payment method or refine your search.");
         }
-        const method = resolveConfirmationMethod(pay_with, pending?.method, compatibleMethods);
-        const spendCheckMethod = method ?? normalizedRequestedMethod;
+        if (!activeCreditPack && compatibleMethods.length === 0) {
+            return text(`No compatible payment methods are configured for ${selected.name}.\n\n` +
+                "Use wallet_status to review your current payment methods.");
+        }
+        const method = resolveConfirmationMethod(requestedMethod, pending?.method, compatibleMethods);
+        const spendCheckMethod = method ?? normalizedRequestedMethod ?? compatibleMethods[0];
         const selectedPrice = parseFloat(selected.pricePerRunUsd ?? "0.01");
         const estimatedCost = selectedPrice;
         const needsPolicyConfirmation = !activeCreditPack && requiresPolicyConfirmation(spendCheckMethod, estimatedCost);
@@ -268,7 +275,7 @@ export function registerSolveTools(server) {
             storeFeedbackToken(jobId, result.feedback_token, agentId);
         }
         if (status === "processing") {
-            const pollResult = await pollSolveJob(jobId);
+            const pollResult = await pollSolveJob(jobId, method);
             if (pollResult.status === "completed") {
                 const asyncFormatted = formatRunResult({
                     ...result,

package/dist/tools/wallet.js

@@ -1,6 +1,8 @@
 import { z } from "zod";
 import { getWallets, getCardConfig, setCardConfig, addWallet, getPendingCardSetupToken, getSpendPolicy, setSpendPolicy, } from "../core/config.js";
-import { getWalletAddress } from "../core/payments.js";
+import { getWalletAddress, isCardPaymentEnabled } from "../core/payments.js";
+import { fetchUsdcBalance } from "../core/balances.js";
+import { getSettings } from "../core/settings.js";
 import { getOrCreatePendingCardSetup, formatCardSetupBlocks, getCardCapabilities, pollCardSetup, } from "../core/card-setup.js";
 import { isOwsAvailable, createOwsWallet, importKeyToOws, listOwsWallets, listOwsWalletsByChain, } from "../core/ows-adapter.js";
 import { ensureConsumerPrincipal, getConsumerPrincipal } from "../core/principal.js";
@@ -17,18 +19,33 @@ export function registerWalletTools(server) {
         if (wallets.length === 0 && !card && !pendingCardSetupToken) {
             return text("No payment methods configured.\nUse wallet_setup to create or import a wallet.");
         }
-        const lines = ["Payment methods:"];
+        const settings = await getSettings();
+        const networkLabel = settings ? ` (${settings.network})` : "";
+        const lines = [`Payment methods${networkLabel}:`];
         for (const w of wallets) {
             const label = w.label ? ` (${w.label})` : "";
             const storage = w.keyType === "ows" ? " [encrypted]" : " [plaintext]";
-            const chainAddresses = await Promise.all(w.chains.map(async (chainName) => {
+            const chainLines = await Promise.all(w.chains.map(async (chainName) => {
                 const addr = await getWalletAddress(chainName);
-                return `${chainName}: ${addr ?? "unknown"}`;
+                if (!addr)
+                    return `${chainName}: unknown`;
+                let balanceStr = "";
+                if (chainName === "tempo" || chainName === "base" || chainName === "solana") {
+                    const balance = await fetchUsdcBalance(chainName, addr);
+                    if (balance !== null) {
+                        const num = Number(balance);
+                        balanceStr = `   ${Number.isFinite(num) ? num.toFixed(4).replace(/\.?0+$/, "") : balance} USDC`;
+                    }
+                }
+                return `${chainName}: ${addr}${balanceStr}`;
             }));
-            lines.push(`  ${w.id}${label}${storage}: ${chainAddresses.join(" | ")}`);
+            lines.push(`  ${w.id}${label}${storage}:`);
+            for (const line of chainLines)
+                lines.push(`    ${line}`);
         }
-        if (card) {
-            lines.push(`  Card: ${card.brand} ****${card.last4}`);
+        if (card && isCardPaymentEnabled()) {
+            const stripeMode = settings?.stripe.mode === "test" ? " [Stripe test mode]" : "";
+            lines.push(`  Card: ${card.brand} ****${card.last4}${stripeMode}`);
             const capabilities = await getCardCapabilities();
             if (capabilities.spt_status === "enabled") {
                 lines.push("  Card MPP: ready");
@@ -49,7 +66,7 @@ export function registerWalletTools(server) {
         return text(lines.join("\n"));
     });
     // ── wallet_setup (NEW) ──────────────────────────────────────────
-    server.tool("wallet_setup", "Set up or manage payment methods. Options: 'add-card' to connect a credit/debit card (recommended), 'remove-card' to disconnect a card, 'create' a crypto wallet, or 'import' an existing key. For crypto wallet changes (removal, key rotation), direct users to edit their config files manually — never handle private keys programmatically.", {
+    server.tool("wallet_setup", "Set up or manage payment methods. Options: 'add-card' to connect a credit/debit card, 'remove-card' to disconnect a card, 'create' a crypto wallet, or 'import' an existing key. After card setup, use wallet_status to confirm whether card-backed MPP is ready. For crypto wallet changes (removal, key rotation), direct users to edit their config files manually — never handle private keys programmatically.", {
         action: z
             .enum(["create", "import", "add-card", "remove-card"])
             .describe("'add-card' to connect a card, 'remove-card' to disconnect it, 'create' a crypto wallet, or 'import' an existing key"),
@@ -66,6 +83,9 @@ export function registerWalletTools(server) {
     }, async ({ action, name, key, chain }) => {
         // ── Card setup flow ──────────────────────────────────────
         if (action === "add-card") {
+            if (!isCardPaymentEnabled()) {
+                return text("Card payments are temporarily unavailable. Use wallet_setup({ action: \"create\" }) for a crypto wallet instead.");
+            }
             const existing = getCardConfig();
             if (existing) {
                 return text(`Card already connected: ${existing.brand} ****${existing.last4}\n\nTo replace it, remove the current card first.`);
@@ -257,8 +277,8 @@ export function registerWalletTools(server) {
         }
     });
     // ── wallet_set_policy (NEW) ─────────────────────────────────────
-    server.tool("wallet_set_policy", "Set spending limits on a wallet to control agent costs. Limits reset daily.", {
-        wallet_id: z.string().describe("Wallet ID to set policy on"),
+    server.tool("wallet_set_policy", "Set client-side spending limits on a wallet to control agent costs in this MCP client. Limits reset daily.", {
+        wallet_id: z.string().describe("Wallet ID to set local policy on"),
         max_per_tx: z
             .number()
             .positive()
@@ -306,10 +326,10 @@ export function registerWalletTools(server) {
             policies.push(`Require confirmation above: $${nextPolicy.requireConfirmationAboveUsd.toFixed(2)}`);
         }
         return text([
-            `Spending policy set for wallet "${wallet_id}":`,
+            `Local spending policy set for wallet "${wallet_id}":`,
             ...policies.map((p) => `  ${p}`),
             "",
-            "Policy will be enforced on all future transactions from this wallet.",
+            "Policy is stored in this MCP client's local config and enforced on future transactions from this wallet on this client.",
         ].join("\n"));
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentwonderland/mcp",
-  "version": "0.1.25",
+  "version": "0.1.26",
   "type": "module",
   "description": "MCP server for the Agent Wonderland AI agent marketplace",
   "bin": {
@@ -25,7 +25,7 @@
     "@modelcontextprotocol/sdk": "^1.12.1",
     "@solana/spl-token": "^0.4.14",
     "@solana/web3.js": "^1.98.4",
-    "mppx": "^0.4.9",
+    "mppx": "^0.5.10",
     "qrcode": "^1.5.4",
     "viem": "^2.47.6",
     "zod": "^3.24.0"

package/src/core/__tests__/api-client.test.ts

@@ -0,0 +1,78 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const {
+  mockGetApiUrl,
+  mockGetApiKey,
+  mockGetPaymentFetch,
+  mockEnsureConsumerPrincipalForMethod,
+  mockGetConsumerPrincipalForMethod,
+  mockGetBaseRebatePrincipal,
+  mockPaymentFetch,
+} = vi.hoisted(() => ({
+  mockGetApiUrl: vi.fn(),
+  mockGetApiKey: vi.fn(),
+  mockGetPaymentFetch: vi.fn(),
+  mockEnsureConsumerPrincipalForMethod: vi.fn(),
+  mockGetConsumerPrincipalForMethod: vi.fn(),
+  mockGetBaseRebatePrincipal: vi.fn(),
+  mockPaymentFetch: vi.fn(),
+}));
+
+vi.mock("../config.js", () => ({
+  getApiUrl: () => mockGetApiUrl(),
+  getApiKey: () => mockGetApiKey(),
+}));
+
+vi.mock("../payments.js", () => ({
+  getPaymentFetch: (...args: unknown[]) => mockGetPaymentFetch(...args),
+}));
+
+vi.mock("../principal.js", () => ({
+  ensureConsumerPrincipal: vi.fn(),
+  ensureConsumerPrincipalForMethod: (...args: unknown[]) => mockEnsureConsumerPrincipalForMethod(...args),
+  getConsumerPrincipal: vi.fn(),
+  getConsumerPrincipalForMethod: (...args: unknown[]) => mockGetConsumerPrincipalForMethod(...args),
+  getBaseRebatePrincipal: (...args: unknown[]) => mockGetBaseRebatePrincipal(...args),
+}));
+
+describe("api-client headers", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockGetApiUrl.mockReturnValue("https://api.agentwonderland.test");
+    mockGetApiKey.mockReturnValue(null);
+    mockGetPaymentFetch.mockResolvedValue(mockPaymentFetch);
+    mockEnsureConsumerPrincipalForMethod.mockResolvedValue(
+      "did:pkh:solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:42W2HfLfveSm1T5et9WTLp2CZ2QXdF2EYCUvyJ2gPpxF",
+    );
+    mockGetConsumerPrincipalForMethod.mockResolvedValue(
+      "did:pkh:eip155:8453:0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+    );
+    mockGetBaseRebatePrincipal.mockResolvedValue(
+      "did:pkh:eip155:8453:0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+    );
+    mockPaymentFetch.mockResolvedValue(new Response(JSON.stringify({ ok: true }), {
+      status: 200,
+      headers: { "content-type": "application/json" },
+    }));
+  });
+
+  it("includes the Base rebate principal alongside the method-specific consumer principal", async () => {
+    const { apiPostWithPayment } = await import("../api-client.js");
+
+    await apiPostWithPayment("/agents/agent-1/run", { input: { text: "hello" } }, "solana");
+
+    expect(mockPaymentFetch).toHaveBeenCalledWith(
+      "https://api.agentwonderland.test/agents/agent-1/run",
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          "X-AW-Consumer-Principal":
+            "did:pkh:solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:42W2HfLfveSm1T5et9WTLp2CZ2QXdF2EYCUvyJ2gPpxF",
+          "X-AW-Rebate-Principal":
+            "did:pkh:eip155:8453:0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+        }),
+      }),
+    );
+  });
+});