@agentwonderland/mcp 0.1.25 → 0.1.26

package/src/tools/__tests__/wallet.test.ts

@@ -0,0 +1,289 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+type WalletEntry = {
+  id: string;
+  keyType: "evm" | "ows";
+  key?: string;
+  owsWalletId?: string;
+  chains: string[];
+  defaultChain?: string;
+  label?: string;
+};
+
+type CardConfig = {
+  consumerToken: string;
+  paymentMethodId?: string;
+  last4: string;
+  brand: string;
+} | null;
+
+type WalletToolResult = {
+  content: Array<{ type: "text"; text: string }>;
+};
+
+const state = vi.hoisted(() => ({
+  wallets: [] as WalletEntry[],
+  addedWallets: [] as WalletEntry[],
+  card: null as CardConfig,
+  pendingCardSetupToken: null as string | null,
+  spendPolicies: {} as Record<string, unknown>,
+  consumerPrincipal: "did:pkh:eip155:8453:0xabc",
+  owsAvailable: true,
+  owsWallets: [] as Array<{ id: string; name: string; address: string }>,
+  owsWalletsByChain: [] as Array<{ id: string; name: string; address: string }>,
+  createdWalletCalls: [] as Array<{ name: string; chain: "evm" | "solana" }>,
+  importWalletCalls: [] as Array<{ privateKey: string; name: string; chain: "evm" | "solana" }>,
+  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: [] as Array<{ token: string; timeoutMs: number }>,
+  pollCardSetupResult: null as
+    | {
+      brand: string;
+      last4: string;
+      consumerToken: string;
+    }
+    | null,
+  setCardConfigCalls: [] as CardConfig[],
+}));
+
+vi.mock("../../core/config.js", () => ({
+  addWallet: (wallet: WalletEntry) => {
+    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: string) => state.spendPolicies[walletId] ?? null,
+  getWallets: () => state.wallets,
+  setCardConfig: (card: CardConfig) => {
+    state.card = card;
+    state.setCardConfigCalls.push(card);
+  },
+  setSpendPolicy: (walletId: string, policy: unknown) => {
+    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: string, timeoutMs: number) => {
+    state.pollCardSetupCalls.push({ token, timeoutMs });
+    return state.pollCardSetupResult;
+  },
+}));
+
+vi.mock("../../core/ows-adapter.js", () => ({
+  createOwsWallet: async (name: string, chain: "evm" | "solana") => {
+    state.createdWalletCalls.push({ name, chain });
+    return state.createdWalletResult;
+  },
+  importKeyToOws: async (privateKey: string, name: string, chain: "evm" | "solana") => {
+    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(): void {
+  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(): Promise<(args: Record<string, unknown>) => Promise<WalletToolResult>> {
+  const tools = new Map<string, (args: Record<string, unknown>) => Promise<WalletToolResult>>();
+  const server = {
+    tool: (
+      name: string,
+      _description: string,
+      _schema: unknown,
+      handler: (args: Record<string, unknown>) => Promise<WalletToolResult>,
+    ) => {
+      tools.set(name, handler);
+    },
+  } as unknown as McpServer;
+
+  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: WalletToolResult): string {
+  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/src/tools/_payment-confirmation.ts

@@ -47,6 +47,6 @@ export function formatPaymentChoicePrompt(
     ...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/src/tools/jobs.ts

@@ -18,7 +18,16 @@ export function registerJobTools(server: McpServer): void {
       job_id: z.string().describe("Job ID (UUID)"),
     },
     async ({ job_id }) => {
-      const result = await apiGet<Record<string, unknown>>(`/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<Record<string, unknown>>(url);
       if (result.status === "processing") {
         return text(`Job ${job_id} is still processing...`);
       }

package/src/tools/passes.ts

@@ -4,6 +4,7 @@ import { apiGet, apiPostWithPayment } from "../core/api-client.js";
 import {
   formatCreditPack,
   formatCreditPackOffer,
+  getCreditPackInventory,
   getCreditPackProgram,
 } from "../core/passes.js";
 import {
@@ -13,7 +14,7 @@ import {
   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,
@@ -84,7 +85,6 @@ export function registerPassTools(server: McpServer): void {
 
       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 ?? ""))
@@ -155,6 +155,7 @@ export function registerPassTools(server: McpServer): void {
       }
 
       const method = resolveConfirmationMethod(pay_with, pending?.method, compatibleMethods);
+      const principal = await ensureConsumerPrincipalForMethod(method);
       if (requiresSpendConfirmation() && !confirmed) {
         pendingCreditPackPurchases.set(agent.id, {
           agentId: agent.id,
@@ -192,7 +193,8 @@ export function registerPassTools(server: McpServer): void {
         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"));
     },
   );
@@ -202,10 +204,14 @@ export function registerPassTools(server: McpServer): void {
     "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)"),
+      pay_with: z.string().optional().describe("Optional payment method context used to inspect the matching consumer principal."),
     },
-    async ({ agent_id }) => {
+    async ({ agent_id, pay_with }) => {
       const agent = await getAgent(agent_id);
-      const result = await apiGet<CreditPackInventory>(`/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}`,

package/src/tools/run.ts

@@ -32,9 +32,10 @@ const POLL_MAX_MS = 120000;
 
 async function pollJobUntilDone(
   jobId: string,
+  paymentMethod?: string,
 ): Promise<{ status: string; output?: unknown; error_code?: string }> {
   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) {
@@ -100,7 +101,7 @@ export function registerRunTools(server: McpServer): void {
     {
       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 }) => {
@@ -126,21 +127,21 @@ export function registerRunTools(server: McpServer): void {
 
       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);
+      const requestedMethod = pay_with ?? pending?.method;
+      const normalizedRequestedMethod = requestedMethod ? normalizePaymentMethod(requestedMethod) : null;
+      const creditPackInventory = await getCreditPackInventory(agent.id, requestedMethod);
+      const activeCreditPack = getActiveCreditPack(creditPackInventory);
 
-      if (!normalizedRequestedMethod) {
+      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` +
@@ -148,8 +149,15 @@ export function registerRunTools(server: McpServer): void {
         );
       }
 
-      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({
@@ -278,7 +286,7 @@ export function registerRunTools(server: McpServer): void {
       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/src/tools/solve.ts

@@ -30,9 +30,10 @@ const POLL_MAX_MS = 120000;
 
 async function pollSolveJob(
   jobId: string,
+  paymentMethod?: string,
 ): Promise<{ status: string; output?: unknown; error_code?: string }> {
   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) {
@@ -139,7 +140,8 @@ export function registerSolveTools(server: McpServer): void {
         .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()
@@ -162,10 +164,10 @@ export function registerSolveTools(server: McpServer): void {
       const pendingKey = makeSolvePendingKey(intent, input, budget);
       const pending = pendingSolves.get(pendingKey);
       const configuredMethods = getConfiguredMethods();
-      const requestedMethod = pay_with;
-      const normalizedRequestedMethod = normalizePaymentMethod(requestedMethod);
+      const requestedMethod = pay_with ?? pending?.method;
+      const normalizedRequestedMethod = requestedMethod ? normalizePaymentMethod(requestedMethod) : null;
 
-      if (!normalizedRequestedMethod) {
+      if (requestedMethod && !normalizedRequestedMethod) {
         return text(
           `Payment method "${requestedMethod}" is not configured.\n\n` +
           "Use wallet_status to review your current payment methods.",
@@ -200,11 +202,13 @@ export function registerSolveTools(server: McpServer): void {
         const tipMsg = result.feedback_token ? await autoTip(jobId, agentId, agentName, result.feedback_token as string) : "";
         return multiText(formatRunResult(result), feedbackAsk(jobId, agentId, usedCreditPack ? undefined : cost, tipMsg));
       } catch (err: unknown) {
-        const isAuthError =
+        const status =
           err instanceof Error &&
-          "status" in err &&
-          (err as { status: number }).status === 401;
-        if (!isAuthError || !hasWalletConfigured()) throw err;
+          "status" in err
+            ? (err as { status: number }).status
+            : undefined;
+        const isRecoverableDirectSolveError = status === 401 || status === 402;
+        if (!isRecoverableDirectSolveError || !hasWalletConfigured()) throw err;
       }
 
       const params = new URLSearchParams({ q: intent, limit: "5" });
@@ -226,10 +230,10 @@ export function registerSolveTools(server: McpServer): void {
         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` +
@@ -237,8 +241,15 @@ export function registerSolveTools(server: McpServer): void {
         );
       }
 
-      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;
@@ -334,7 +345,7 @@ export function registerSolveTools(server: McpServer): void {
       }
 
       if (status === "processing") {
-        const pollResult = await pollSolveJob(jobId);
+        const pollResult = await pollSolveJob(jobId, method);
         if (pollResult.status === "completed") {
           const asyncFormatted = formatRunResult({
             ...result,

package/src/tools/wallet.ts

@@ -9,7 +9,9 @@ import {
   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,
@@ -47,25 +49,36 @@ export function registerWalletTools(server: McpServer): void {
         );
       }
 
-      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(
+        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");
@@ -91,7 +104,7 @@ export function registerWalletTools(server: McpServer): void {
   // ── 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.",
+    "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"])
@@ -112,6 +125,9 @@ export function registerWalletTools(server: McpServer): void {
     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.`);
@@ -341,9 +357,9 @@ export function registerWalletTools(server: McpServer): void {
   // ── wallet_set_policy (NEW) ─────────────────────────────────────
   server.tool(
     "wallet_set_policy",
-    "Set spending limits on a wallet to control agent costs. Limits reset daily.",
+    "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 policy on"),
+      wallet_id: z.string().describe("Wallet ID to set local policy on"),
       max_per_tx: z
         .number()
         .positive()
@@ -403,10 +419,10 @@ export function registerWalletTools(server: McpServer): void {
       }
       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"),
       );
     },