@agentwonderland/mcp 0.1.25 → 0.1.27

package/src/core/balances.ts

@@ -0,0 +1,63 @@
+import { getSettings, type ChainSettings } from "./settings.js";
+
+const ERC20_BALANCE_ABI = [
+  {
+    type: "function",
+    name: "balanceOf",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+  },
+] as const;
+
+async function fetchEvmUsdcBalance(
+  chain: ChainSettings,
+  address: string,
+): Promise<string | null> {
+  try {
+    const { createPublicClient, http, formatUnits } = await import("viem");
+    const client = createPublicClient({ transport: http(chain.rpcUrl) });
+    const raw = await client.readContract({
+      address: chain.usdc as `0x${string}`,
+      abi: ERC20_BALANCE_ABI,
+      functionName: "balanceOf",
+      args: [address as `0x${string}`],
+    });
+    return formatUnits(raw as bigint, 6);
+  } catch {
+    return null;
+  }
+}
+
+async function fetchSolanaUsdcBalance(
+  chain: ChainSettings,
+  address: string,
+): Promise<string | null> {
+  try {
+    const { Connection, PublicKey } = await import("@solana/web3.js");
+    const connection = new Connection(chain.rpcUrl, "confirmed");
+    const owner = new PublicKey(address);
+    const mint = new PublicKey(chain.usdc);
+    const accounts = await connection.getParsedTokenAccountsByOwner(owner, { mint });
+    let total = 0;
+    for (const { account } of accounts.value) {
+      const amount = (account.data as any)?.parsed?.info?.tokenAmount?.uiAmount;
+      if (typeof amount === "number") total += amount;
+    }
+    return total.toString();
+  } catch {
+    return null;
+  }
+}
+
+export async function fetchUsdcBalance(
+  chain: "tempo" | "base" | "solana",
+  address: string,
+): Promise<string | null> {
+  const settings = await getSettings();
+  if (!settings) return null;
+  const chainConfig = settings.chains[chain];
+  if (!chainConfig) return null;
+  if (chain === "solana") return fetchSolanaUsdcBalance(chainConfig, address);
+  return fetchEvmUsdcBalance(chainConfig, address);
+}

package/src/core/base-charge.ts

@@ -10,7 +10,9 @@ import { toAtomicAmount } from "./amount-utils.js";
 
 // Base USDC (Circle native)
 const BASE_USDC = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" as const;
+const BASE_SEPOLIA_USDC = "0x036CbD53842c5426634e7929541eC2318f3dCF7e" as const;
 const BASE_CHAIN_ID = 8453;
+const BASE_SEPOLIA_CHAIN_ID = 84532;
 
 // Standard ERC-20 transfer function ABI
 const ERC20_ABI = [
@@ -66,22 +68,27 @@ export function baseChargeClient(config: BaseChargeClientConfig) {
       const { request } = challenge;
       const amount = toAtomicAmount(request.amount, request.decimals ?? 6);
       const recipient = request.recipient as `0x${string}`;
-      const currency = (request.currency ?? BASE_USDC) as `0x${string}`;
+      const chainId = request.chainId ?? BASE_CHAIN_ID;
+      const currency = (request.currency
+        ?? (chainId === BASE_SEPOLIA_CHAIN_ID ? BASE_SEPOLIA_USDC : BASE_USDC)) as `0x${string}`;
 
       // Dynamic imports to keep the module lightweight
       const { createWalletClient, createPublicClient, http } = await import("viem");
-      const { base } = await import("viem/chains");
+      const { base, baseSepolia } = await import("viem/chains");
 
-      const rpcUrl = config.rpcUrl ?? "https://mainnet.base.org";
+      const chain = chainId === BASE_SEPOLIA_CHAIN_ID ? baseSepolia : base;
+      const rpcUrl = config.rpcUrl ?? (chainId === BASE_SEPOLIA_CHAIN_ID
+        ? "https://sepolia.base.org"
+        : "https://mainnet.base.org");
 
       const walletClient = createWalletClient({
         account: config.account,
-        chain: base,
+        chain,
         transport: http(rpcUrl),
       });
 
       const publicClient = createPublicClient({
-        chain: base,
+        chain,
         transport: http(rpcUrl),
       });
 
@@ -99,7 +106,7 @@ export function baseChargeClient(config: BaseChargeClientConfig) {
       return Credential.serialize({
         challenge,
         payload: { hash, type: "hash" as const },
-        source: `did:pkh:eip155:${BASE_CHAIN_ID}:${config.account.address}`,
+        source: `did:pkh:eip155:${chainId}:${config.account.address}`,
       });
     },
   });

package/src/core/formatters.ts

@@ -112,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[] = [];
 
@@ -146,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> = {
@@ -68,7 +77,7 @@ async function initEvmMppForChain(
   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) {
@@ -83,13 +92,14 @@ async function initEvmMppForChain(
 
     const methods = [];
     if (chain === "tempo") {
-      methods.push(tempo({ account }));
+      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 });
+    const mppx = Mppx.create({ methods: methods as any, polyfill: false });
     return mppx.fetch.bind(mppx) as typeof fetch;
   } catch {
     return null;
@@ -106,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 {
@@ -146,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 {
@@ -177,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) {
@@ -286,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,6 +9,7 @@ import { Connection, Keypair, PublicKey, Transaction, sendAndConfirmTransaction
 import {
   ASSOCIATED_TOKEN_PROGRAM_ID,
   TOKEN_PROGRAM_ID,
+  createAssociatedTokenAccountInstruction,
   createTransferCheckedInstruction,
   getAssociatedTokenAddressSync,
 } from "@solana/spl-token";
@@ -75,24 +76,40 @@ 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) {
@@ -114,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/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/index.ts

@@ -14,7 +14,6 @@ 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";
@@ -47,13 +46,13 @@ 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.",
-        "- run_agent() and solve() require 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.",
@@ -81,7 +80,6 @@ export async function startMcpServer(): Promise<void> {
   registerFavoriteTools(server);
   registerTipTools(server);
   registerPassTools(server);
-  registerObservabilityTools(server);
 
   // Register resources
   registerAgentResources(server);

package/src/prompts/index.ts

@@ -62,7 +62,7 @@ export function registerPrompts(server: McpServer) {
             "",
             "Steps:",
             "1. Use search_agents to find relevant agents",
-            "2. Use compare_agents on the top 2-3 candidates",
+            "2. Use get_agent to inspect the top candidate (schema, pricing, rating)",
             "3. Recommend the best one based on price, rating, and success rate",
             "4. Ask if I want to run it",
           ].join("\n"),