@agentwonderland/mcp 0.1.24 → 0.1.26

package/src/core/formatters.ts

@@ -36,11 +36,10 @@ export function isFileOutput(output: unknown): output is { type: "file"; url: st
 
 // ── Price formatting ─────────────────────────────────────────────
 
-export function formatPrice(pricePer1kTokens?: string | null, pricingModel?: string | null): string {
-  if (!pricePer1kTokens) return "free";
-  const p = parseFloat(pricePer1kTokens);
-  if (pricingModel === "fixed") return `$${p.toFixed(2)}/req`;
-  return `$${p.toFixed(3)}/1k tokens`;
+export function formatPrice(pricePerRunUsd?: string | null): string {
+  if (!pricePerRunUsd) return "free";
+  const p = parseFloat(pricePerRunUsd);
+  return `$${p.toFixed(2)}/req`;
 }
 
 // ── Agent line (compact, one line per agent) ─────────────────────
@@ -52,8 +51,7 @@ interface AgentLike {
   avgRating?: number | null;
   ratingCount?: number;
   totalExecutions?: number;
-  pricePer1kTokens?: string;
-  pricingModel?: string;
+  pricePerRunUsd?: string;
   stats?: { completedJobs?: number; avgRating?: number | null };
   [key: string]: unknown;
 }
@@ -63,7 +61,7 @@ export function agentLine(agent: AgentLike): string {
   const slug = agent.slug ? ` (${agent.slug})` : "";
   const rating = agent.avgRating ?? agent.stats?.avgRating ?? null;
   const jobs = agent.stats?.completedJobs ?? agent.totalExecutions ?? 0;
-  const price = formatPrice(agent.pricePer1kTokens, agent.pricingModel);
+  const price = formatPrice(agent.pricePerRunUsd);
   const reliability = agent.successRate != null && Number(agent.successRate) < 1
     ? ` • ${(Number(agent.successRate) * 100).toFixed(0)}% reliable`
     : "";
@@ -114,14 +112,21 @@ interface RunResultLike {
   error_code?: string;
   latency_ms?: number;
   execution_latency_ms?: number;
-  cost?: number;
-  estimated_cost?: number;
+  cost?: number | string;
+  settled_amount?: number | string;
+  estimated_cost?: number | string;
   input_tokens?: number;
   tags?: string[];
   consumption_mode?: string;
   credit_pack_id?: string;
 }
 
+function toDisplayCost(value: number | string | null | undefined): number | null {
+  if (value == null) return null;
+  const numeric = typeof value === "number" ? value : Number.parseFloat(value);
+  return Number.isFinite(numeric) ? numeric : null;
+}
+
 export function formatRunResult(result: RunResultLike, opts?: { paymentMethod?: string }): string {
   const lines: string[] = [];
 
@@ -148,7 +153,7 @@ export function formatRunResult(result: RunResultLike, opts?: { paymentMethod?:
   }
 
   // Summary line
-  const cost = result.cost ?? result.estimated_cost;
+  const cost = toDisplayCost(result.cost ?? result.settled_amount ?? result.estimated_cost);
   const usedCreditPack = result.consumption_mode === "credit_pack";
   const status = result.status === "success" || result.status === "completed" ? "✓" : "✗";
   const agent = result.agent_name ?? result.agent_id ?? "";

package/src/core/passes.ts

@@ -45,9 +45,12 @@ export function getCreditPackProgram(agent: AgentRecord): CreditPackProgramInfo
   return creditPacks ?? null;
 }
 
-export async function getCreditPackInventory(agentId: string): Promise<CreditPackInventory | null> {
+export async function getCreditPackInventory(agentId: string, method?: string): Promise<CreditPackInventory | null> {
   try {
-    return await apiGet<CreditPackInventory>(`/agents/${agentId}/credit-packs`, { ensureConsumerPrincipal: true });
+    return await apiGet<CreditPackInventory>(`/agents/${agentId}/credit-packs`, {
+      ensureConsumerPrincipal: true,
+      principalMethod: method,
+    });
   } catch {
     return null;
   }

package/src/core/payments.ts

@@ -21,6 +21,15 @@ import {
 } from "./config.js";
 import type { AgentRecord } from "./types.js";
 
+// Feature flag: disable card payment for launch. Flip to true once Stripe
+// approves the live SPT issuer. Config/card state is still persisted so this
+// can be re-enabled without reconfiguring wallets.
+const ENABLE_CARD_PAYMENT = false;
+
+export function isCardPaymentEnabled(): boolean {
+  return ENABLE_CARD_PAYMENT;
+}
+
 // Cache per wallet+chain combo to avoid re-initializing
 const fetchCache = new Map<string, typeof fetch>();
 const REGISTRY_METHOD_MAP: Record<string, string> = {
@@ -63,9 +72,12 @@ function clearStaleCardCache(activeKey?: string): void {
 
 // ── Per-protocol initializers ───────────────────────────────────
 
-async function initMpp(wallet: WalletEntry): Promise<typeof fetch | null> {
+async function initEvmMppForChain(
+  wallet: WalletEntry,
+  chain: "tempo" | "base",
+): Promise<typeof fetch | null> {
   try {
-    const { Mppx, tempo } = await import("mppx/client");
+    const { Mppx } = await import("mppx/client");
     let account;
 
     if (wallet.keyType === "ows" && wallet.owsWalletId) {
@@ -78,8 +90,16 @@ async function initMpp(wallet: WalletEntry): Promise<typeof fetch | null> {
       return null;
     }
 
-    const { baseChargeClient } = await import("./base-charge.js");
-    const mppx = Mppx.create({ methods: [tempo({ account }), baseChargeClient({ account })] as any });
+    const methods = [];
+    if (chain === "tempo") {
+      const { tempoChargeClient } = await import("./tempo-charge.js");
+      methods.push(tempoChargeClient({ account }));
+    } else {
+      const { baseChargeClient } = await import("./base-charge.js");
+      methods.push(baseChargeClient({ account }));
+    }
+
+    const mppx = Mppx.create({ methods: methods as any, polyfill: false });
     return mppx.fetch.bind(mppx) as typeof fetch;
   } catch {
     return null;
@@ -96,6 +116,7 @@ async function initSolanaMpp(wallet: WalletEntry): Promise<typeof fetch | null>
     const { solanaChargeClient } = await import("./solana-charge.js");
     const mppx = Mppx.create({
       methods: [solanaChargeClient({ wallet })] as any,
+      polyfill: false,
     });
     return mppx.fetch.bind(mppx) as typeof fetch;
   } catch {
@@ -136,6 +157,7 @@ async function initCard(): Promise<typeof fetch | null> {
           return spt;
         },
       })] as any,
+      polyfill: false,
     });
     return mppx.fetch.bind(mppx) as typeof fetch;
   } catch {
@@ -150,7 +172,10 @@ async function initForChain(wallet: WalletEntry, chain: string): Promise<typeof
   if (chain === "solana") {
     return initSolanaMpp(wallet);
   }
-  return initMpp(wallet);
+  if (chain === "tempo" || chain === "base") {
+    return initEvmMppForChain(wallet, chain);
+  }
+  return null;
 }
 
 // ── Public API ──────────────────────────────────────────────────
@@ -164,6 +189,9 @@ async function initForChain(wallet: WalletEntry, chain: string): Promise<typeof
 export async function getPaymentFetch(method?: string): Promise<typeof fetch> {
   // Card payment
   if (method === "card") {
+    if (!ENABLE_CARD_PAYMENT) {
+      throw new Error('Card payments are temporarily unavailable. Use a crypto wallet (tempo, base, or solana).');
+    }
     const ck = cardCacheKey();
     clearStaleCardCache(ck ?? undefined);
     if (!ck) {
@@ -273,14 +301,14 @@ export function getConfiguredMethods(): string[] {
     }
   }
 
-  // Add card if configured
-  if (getCardConfig()) {
+  // Add card if configured (gated for launch)
+  if (ENABLE_CARD_PAYMENT && getCardConfig()) {
     methods.push("card");
   }
 
-  // Respect defaultPaymentMethod — move it to front of list
+  // Respect defaultPaymentMethod — move it to front of list (ignore card when disabled)
   const defaultMethod = getConfig().defaultPaymentMethod;
-  if (defaultMethod) {
+  if (defaultMethod && (defaultMethod !== "card" || ENABLE_CARD_PAYMENT)) {
     const idx = methods.indexOf(defaultMethod);
     if (idx > 0) {
       methods.splice(idx, 1);

package/src/core/principal.ts

@@ -1,4 +1,10 @@
-import { addWallet, getDefaultWallet, getWallets, type WalletEntry } from "./config.js";
+import {
+  addWallet,
+  getDefaultWallet,
+  getWallets,
+  resolveWalletAndChain,
+  type WalletEntry,
+} from "./config.js";
 import { getWalletAddress } from "./payments.js";
 import {
   createOwsWallet,
@@ -39,6 +45,12 @@ async function walletPrincipal(wallet: WalletEntry): Promise<string | null> {
   return null;
 }
 
+async function principalForChain(chain: string): Promise<string | null> {
+  const address = await getWalletAddress(chain);
+  if (!address) return null;
+  return principalFromAddress(address, chain === "solana" ? "solana" : "evm");
+}
+
 function preferredWallets(): WalletEntry[] {
   const wallets = getWallets();
   const defaultWallet = getDefaultWallet();
@@ -115,6 +127,21 @@ export async function getConsumerPrincipal(): Promise<string | null> {
   return null;
 }
 
+export async function getBaseRebatePrincipal(): Promise<string | null> {
+  return (await principalForChain("base")) ?? principalForChain("tempo");
+}
+
+export async function getConsumerPrincipalForMethod(method?: string): Promise<string | null> {
+  if (!method || method === "card") {
+    return getConsumerPrincipal();
+  }
+
+  const resolved = resolveWalletAndChain(method);
+  if (!resolved) return null;
+
+  return principalForChain(resolved.chain);
+}
+
 export async function ensureConsumerPrincipal(): Promise<string> {
   const existing = await getConsumerPrincipal();
   if (existing) return existing;
@@ -126,3 +153,17 @@ export async function ensureConsumerPrincipal(): Promise<string> {
   }
   return principal;
 }
+
+export async function ensureConsumerPrincipalForMethod(method?: string): Promise<string> {
+  const existing = await getConsumerPrincipalForMethod(method);
+  if (existing) return existing;
+
+  if (method && method !== "card") {
+    throw new Error(
+      `Could not derive a consumer principal for payment method "${method}". ` +
+      "Check wallet_status and confirm that chain is configured for the active wallet.",
+    );
+  }
+
+  return ensureConsumerPrincipal();
+}

package/src/core/settings.ts

@@ -0,0 +1,36 @@
+import { getApiUrl } from "./config.js";
+
+export interface ChainSettings {
+  chainId: number | string;
+  usdc: string;
+  rpcUrl: string;
+  explorer?: string;
+}
+
+export interface PublicSettings {
+  network: "testnet" | "mainnet";
+  stripe: { mode: "test" | "live" };
+  chains: {
+    tempo: ChainSettings;
+    base: ChainSettings;
+    solana: ChainSettings & { cluster: "mainnet-beta" | "devnet" };
+  };
+}
+
+let cache: { data: PublicSettings; expiresAt: number } | null = null;
+const TTL_MS = 5 * 60 * 1000;
+
+export async function getSettings(): Promise<PublicSettings | null> {
+  const now = Date.now();
+  if (cache && cache.expiresAt > now) return cache.data;
+
+  try {
+    const res = await fetch(`${getApiUrl()}/settings`);
+    if (!res.ok) return cache?.data ?? null;
+    const data = await res.json() as PublicSettings;
+    cache = { data, expiresAt: now + TTL_MS };
+    return data;
+  } catch {
+    return cache?.data ?? null;
+  }
+}

package/src/core/solana-charge.ts

@@ -9,10 +9,12 @@ import { Connection, Keypair, PublicKey, Transaction, sendAndConfirmTransaction
 import {
   ASSOCIATED_TOKEN_PROGRAM_ID,
   TOKEN_PROGRAM_ID,
+  createAssociatedTokenAccountInstruction,
   createTransferCheckedInstruction,
   getAssociatedTokenAddressSync,
 } from "@solana/spl-token";
 import type { WalletEntry } from "./config.js";
+import { toAtomicAmount } from "./amount-utils.js";
 
 export const SOLANA_USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v" as const;
 export const SOLANA_CHAIN_ID = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp" as const;
@@ -74,31 +76,47 @@ interface SolanaChargeClientConfig {
   rpcUrl?: string;
 }
 
-async function resolveRecipientTokenAccount(
+export async function resolveRecipientTokenAccount(
   connection: Connection,
   mint: PublicKey,
   recipient: PublicKey,
-): Promise<PublicKey> {
+): Promise<{ tokenAccount: PublicKey; needsCreateAssociatedAccount: boolean }> {
   const accountInfo = await connection.getParsedAccountInfo(recipient, "confirmed");
   const owner = accountInfo.value?.owner;
   if (owner && owner.toBase58() === TOKEN_PROGRAM_ID.toBase58()) {
-    return recipient;
+    return {
+      tokenAccount: recipient,
+      needsCreateAssociatedAccount: false,
+    };
   }
 
-  return getAssociatedTokenAddressSync(
+  const associatedTokenAccount = getAssociatedTokenAddressSync(
     mint,
     recipient,
     false,
     TOKEN_PROGRAM_ID,
     ASSOCIATED_TOKEN_PROGRAM_ID,
   );
+  const associatedAccountInfo = await connection.getParsedAccountInfo(associatedTokenAccount, "confirmed");
+  const associatedOwner = associatedAccountInfo.value?.owner;
+  if (associatedOwner && associatedOwner.toBase58() === TOKEN_PROGRAM_ID.toBase58()) {
+    return {
+      tokenAccount: associatedTokenAccount,
+      needsCreateAssociatedAccount: false,
+    };
+  }
+
+  return {
+    tokenAccount: associatedTokenAccount,
+    needsCreateAssociatedAccount: true,
+  };
 }
 
 export function solanaChargeClient(config: SolanaChargeClientConfig) {
   return Method.toClient(solanaChargeMethod as any, {
     async createCredential({ challenge }: any) {
       const { request } = challenge;
-      const amount = BigInt(request.amount);
+      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);
@@ -113,27 +131,44 @@ export function solanaChargeClient(config: SolanaChargeClientConfig) {
         TOKEN_PROGRAM_ID,
         ASSOCIATED_TOKEN_PROGRAM_ID,
       );
-      const destinationTokenAccount = await resolveRecipientTokenAccount(
+      const destination = await resolveRecipientTokenAccount(
         connection,
         mint,
         recipient,
       );
+      const instructions = [];
+
+      if (destination.needsCreateAssociatedAccount) {
+        instructions.push(
+          createAssociatedTokenAccountInstruction(
+            owner,
+            destination.tokenAccount,
+            recipient,
+            mint,
+            TOKEN_PROGRAM_ID,
+            ASSOCIATED_TOKEN_PROGRAM_ID,
+          ),
+        );
+      }
 
-      const instruction = createTransferCheckedInstruction(
+      instructions.push(createTransferCheckedInstruction(
         sourceTokenAccount,
         mint,
-        destinationTokenAccount,
+        destination.tokenAccount,
         owner,
         amount,
         decimals,
-      );
+      ));
 
       const { blockhash } = await connection.getLatestBlockhash("confirmed");
 
       const transaction = new Transaction({
         feePayer: owner,
         recentBlockhash: blockhash,
-      }).add(instruction);
+      });
+      for (const instruction of instructions) {
+        transaction.add(instruction);
+      }
 
       const signature = await sendAndConfirmTransaction(connection, transaction, [keypair], {
         commitment: "confirmed",

package/src/core/spend-policy.ts

@@ -0,0 +1,69 @@
+import {
+  getSpendLedger,
+  getSpendPolicy,
+  saveSpendLedger,
+  type SpendLedgerEntry,
+} from "./config.js";
+
+const LEDGER_RETENTION_DAYS = 35;
+
+function utcDay(now: Date): string {
+  return now.toISOString().slice(0, 10);
+}
+
+function pruneLedger(entries: SpendLedgerEntry[], now: Date): SpendLedgerEntry[] {
+  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: string, now = new Date()): number {
+  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: {
+  method: string;
+  amountUsd: number;
+}): { ok: true } | { ok: false; message: string } {
+  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: string, amountUsd: number): boolean {
+  const policy = getSpendPolicy(method);
+  if (!policy?.requireConfirmationAboveUsd) return false;
+  return amountUsd >= policy.requireConfirmationAboveUsd;
+}
+
+export function recordSpend(method: string, amountUsd: number, now = new Date()): void {
+  const entries = pruneLedger(getSpendLedger(), now);
+  entries.push({
+    method,
+    amountUsd,
+    day: utcDay(now),
+    timestamp: now.toISOString(),
+  });
+  saveSpendLedger(entries);
+}

package/src/core/tempo-charge.ts

@@ -0,0 +1,104 @@
+/**
+ * Custom MPP payment method: Tempo EVM USDC charge (client-side).
+ *
+ * Sends a standard ERC-20 transfer on Tempo and returns the tx hash as the
+ * payment credential.
+ */
+import { Method, Credential, z } from "mppx";
+import type { LocalAccount } from "viem/accounts";
+import { toAtomicAmount } from "./amount-utils.js";
+
+const TEMPO_USDC = "0x20c000000000000000000000b9537d11c60e8b50" as const;
+const PATH_USD = "0x20c0000000000000000000000000000000000000" as const;
+const TEMPO_MAINNET_CHAIN_ID = 4217;
+const TEMPO_TESTNET_CHAIN_ID = 42431;
+
+const ERC20_ABI = [
+  {
+    type: "function",
+    name: "transfer",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "value", type: "uint256" },
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+  },
+] as const;
+
+const tempoChargeMethod = Method.from({
+  name: "tempo" as const,
+  intent: "charge" as const,
+  schema: {
+    credential: {
+      payload: z.object({
+        hash: z.string(),
+        type: z.literal("hash"),
+      }),
+    },
+    request: z.pipe(
+      z.object({
+        amount: z.string(),
+        currency: z.string(),
+        recipient: z.string(),
+        chainId: z.optional(z.number()),
+        decimals: z.optional(z.number()),
+      }),
+      z.transform((v: any) => ({
+        ...v,
+        methodDetails: {
+          chainId: v.chainId ?? TEMPO_MAINNET_CHAIN_ID,
+        },
+      })),
+    ),
+  },
+});
+
+interface TempoChargeClientConfig {
+  account: LocalAccount;
+  rpcUrl?: string;
+}
+
+export function tempoChargeClient(config: TempoChargeClientConfig) {
+  return Method.toClient(tempoChargeMethod as any, {
+    async createCredential({ challenge }: any) {
+      const { request } = challenge;
+      const amount = toAtomicAmount(request.amount, request.decimals ?? 6);
+      const recipient = request.recipient as `0x${string}`;
+      const currency = (request.currency ?? TEMPO_USDC) as `0x${string}`;
+      const chainId = request.methodDetails?.chainId ?? request.chainId ?? TEMPO_MAINNET_CHAIN_ID;
+
+      const { createWalletClient, createPublicClient, http } = await import("viem");
+      const { tempo, tempoModerato } = await import("viem/chains");
+
+      const chain = chainId === TEMPO_TESTNET_CHAIN_ID ? tempoModerato : tempo;
+      const rpcUrl = config.rpcUrl ?? chain.rpcUrls.default.http[0];
+
+      const walletClient = createWalletClient({
+        account: config.account,
+        chain,
+        transport: http(rpcUrl),
+      });
+
+      const publicClient = createPublicClient({
+        chain,
+        transport: http(rpcUrl),
+      });
+
+      const hash = await walletClient.writeContract({
+        address: currency,
+        abi: ERC20_ABI,
+        functionName: "transfer",
+        args: [recipient, amount],
+      });
+
+      await publicClient.waitForTransactionReceipt({ hash });
+
+      return Credential.serialize({
+        challenge,
+        payload: { hash, type: "hash" as const },
+        source: `did:pkh:eip155:${chainId}:${config.account.address}`,
+      });
+    },
+  });
+}

package/src/core/types.ts

@@ -6,8 +6,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;

package/src/index.ts

@@ -14,6 +14,7 @@ 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";
@@ -46,12 +47,14 @@ export async function startMcpServer(): Promise<void> {
         "5. Ask user to rate or tip after a successful run",
         "",
         "PAYMENT:",
-        "- 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.",
+        "- Crypto wallets (Tempo USDC, Base USDC, Solana USDC) are the core supported rails.",
+        "- Saved cards can also be used, but card-backed MPP depends on Stripe Shared Payment Token availability in the current environment.",
         "- 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.",
-        "- If multiple valid payment methods are available for a run and pay_with is not specified, ask the user which one to use.",
-        "- For fully agentic execution, include pay_with explicitly.",
+        "- When a card is configured, it becomes the default payment method. Use wallet_status to confirm whether `Card MPP: ready` before relying on it.",
+        "- run_agent() and solve() auto-detect the default compatible payment method when pay_with is omitted.",
+        "- Include pay_with explicitly when you need a specific rail or want deterministic control over the payment method used.",
+        "- 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.",
@@ -79,6 +82,7 @@ export async function startMcpServer(): Promise<void> {
   registerFavoriteTools(server);
   registerTipTools(server);
   registerPassTools(server);
+  registerObservabilityTools(server);
 
   // Register resources
   registerAgentResources(server);

package/src/prompts/index.ts

@@ -18,7 +18,7 @@ export function registerPrompts(server: McpServer) {
             "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, buy_agent_credit_pack, rating, and tipping work",
+            "4. Briefly explain how solve, run_agent, buy_agent_credit_pack, pay_with selection, rating, and tipping work",
           ].join("\n"),
         },
       }],
@@ -86,7 +86,7 @@ export function registerPrompts(server: McpServer) {
           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"),
         },
       }],
@@ -108,6 +108,8 @@ export function registerPrompts(server: McpServer) {
           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/src/resources/agents.ts

@@ -9,7 +9,7 @@ export function registerAgentResources(server: McpServer) {
     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 {