@agentwonderland/mcp 0.1.23 → 0.1.25

package/src/core/payments.ts

@@ -19,9 +19,23 @@ import {
   getApiUrl,
   type WalletEntry,
 } from "./config.js";
+import type { AgentRecord } from "./types.js";
 
 // Cache per wallet+chain combo to avoid re-initializing
 const fetchCache = new Map<string, typeof fetch>();
+const REGISTRY_METHOD_MAP: Record<string, string> = {
+  tempo: "tempo_usdc",
+  base: "base_usdc",
+  solana: "solana_usdc",
+  card: "stripe_card",
+};
+
+const METHOD_REGISTRY_MAP: Record<string, string> = {
+  tempo_usdc: "tempo",
+  base_usdc: "base",
+  solana_usdc: "solana",
+  stripe_card: "card",
+};
 
 // ── Helpers ─────────────────────────────────────────────────────
 
@@ -33,9 +47,26 @@ function cacheKey(walletId: string, chain: string): string {
   return `${walletId}:${chain}`;
 }
 
+function cardCacheKey(): string | null {
+  const card = getCardConfig();
+  if (!card) return null;
+  return `card:${getApiUrl()}:${card.consumerToken}:${card.paymentMethodId ?? ""}`;
+}
+
+function clearStaleCardCache(activeKey?: string): void {
+  for (const key of fetchCache.keys()) {
+    if (key.startsWith("card:") && key !== activeKey) {
+      fetchCache.delete(key);
+    }
+  }
+}
+
 // ── 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");
     let account;
@@ -50,8 +81,32 @@ 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") {
+      methods.push(tempo({ account }));
+    } else {
+      const { baseChargeClient } = await import("./base-charge.js");
+      methods.push(baseChargeClient({ account }));
+    }
+
+    const mppx = Mppx.create({ methods: methods as any });
+    return mppx.fetch.bind(mppx) as typeof fetch;
+  } catch {
+    return null;
+  }
+}
+
+async function initSolanaMpp(wallet: WalletEntry): Promise<typeof fetch | null> {
+  try {
+    if (wallet.keyType !== "ows" && !wallet.key) {
+      return null;
+    }
+
+    const { Mppx } = await import("mppx/client");
+    const { solanaChargeClient } = await import("./solana-charge.js");
+    const mppx = Mppx.create({
+      methods: [solanaChargeClient({ wallet })] as any,
+    });
     return mppx.fetch.bind(mppx) as typeof fetch;
   } catch {
     return null;
@@ -101,8 +156,14 @@ async function initCard(): Promise<typeof fetch | null> {
 /**
  * Initialize a payment-aware fetch for a given wallet + chain.
  */
-async function initForChain(wallet: WalletEntry, _chain: string): Promise<typeof fetch | null> {
-  return initMpp(wallet);
+async function initForChain(wallet: WalletEntry, chain: string): Promise<typeof fetch | null> {
+  if (chain === "solana") {
+    return initSolanaMpp(wallet);
+  }
+  if (chain === "tempo" || chain === "base") {
+    return initEvmMppForChain(wallet, chain);
+  }
+  return null;
 }
 
 // ── Public API ──────────────────────────────────────────────────
@@ -116,7 +177,11 @@ async function initForChain(wallet: WalletEntry, _chain: string): Promise<typeof
 export async function getPaymentFetch(method?: string): Promise<typeof fetch> {
   // Card payment
   if (method === "card") {
-    const ck = "card:card";
+    const ck = cardCacheKey();
+    clearStaleCardCache(ck ?? undefined);
+    if (!ck) {
+      throw new Error('Payment method "card" is not configured. Use the wallet_setup tool to configure a wallet');
+    }
     if (fetchCache.has(ck)) return fetchCache.get(ck)!;
     const pf = await initCard();
     if (pf) {
@@ -148,7 +213,16 @@ export async function getPaymentFetch(method?: string): Promise<typeof fetch> {
 
   for (const m of configured) {
     if (m === "card") {
-      const ck = "card:card";
+      const ck = cardCacheKey();
+      clearStaleCardCache(ck ?? undefined);
+      if (!ck) {
+        if (m === defaultMethod) {
+          const others = configured.filter((x) => x !== m);
+          const altText = others.length > 0 ? ` Available alternatives: ${others.join(", ")}` : "";
+          throw new Error(`Card payment failed to initialize. Check your card with wallet_status.${altText}`);
+        }
+        continue;
+      }
       if (fetchCache.has(ck)) return fetchCache.get(ck)!;
       const pf = await initCard();
       if (pf) {
@@ -230,6 +304,16 @@ export function getConfiguredMethods(): string[] {
   return methods;
 }
 
+/**
+ * Normalize a requested payment method into the MCP-visible method identifier.
+ * Accepts chain names, wallet IDs, or "card".
+ */
+export function normalizePaymentMethod(method: string): string | null {
+  if (method === "card") return "card";
+  const resolved = resolveWalletAndChain(method);
+  return resolved?.chain ?? null;
+}
+
 /**
  * Human-friendly display name for a payment method identifier.
  */
@@ -250,13 +334,33 @@ export function paymentMethodDisplayName(method: string): string {
  */
 export function getAcceptedPaymentMethods(): string[] {
   const methods = getConfiguredMethods();
-  const map: Record<string, string> = {
-    tempo: "tempo_usdc",
-    base: "base_usdc",
-    solana: "solana_usdc",
-    card: "stripe_card",
-  };
-  return methods.map((m) => map[m]).filter(Boolean);
+  return methods
+    .map((m) => REGISTRY_METHOD_MAP[m])
+    .filter(Boolean);
+}
+
+export function toRegistryPaymentMethod(method: string): string | null {
+  const normalized = normalizePaymentMethod(method);
+  if (!normalized) return null;
+  return REGISTRY_METHOD_MAP[normalized] ?? null;
+}
+
+export function getCompatiblePaymentMethods(
+  agent: Pick<AgentRecord, "payment"> | null | undefined,
+  configuredMethods = getConfiguredMethods(),
+): string[] {
+  const acceptedPayments = agent?.payment?.accepted_payments;
+  if (!Array.isArray(acceptedPayments) || acceptedPayments.length === 0) {
+    return [...configuredMethods];
+  }
+
+  const acceptedMethods = new Set(
+    acceptedPayments
+      .map((payment) => METHOD_REGISTRY_MAP[payment])
+      .filter(Boolean),
+  );
+
+  return configuredMethods.filter((method) => acceptedMethods.has(method));
 }
 
 /**
@@ -270,13 +374,16 @@ export function hasWalletConfigured(): boolean {
  * Get address for a specific method, or the first configured one.
  */
 export async function getWalletAddress(method?: string): Promise<string | null> {
+  let chain: string | undefined;
   let wallet: WalletEntry | undefined;
 
   if (method && method !== "card") {
     const resolved = resolveWalletAndChain(method);
     wallet = resolved?.wallet;
+    chain = resolved?.chain;
   } else if (!method) {
     wallet = getDefaultWallet();
+    chain = wallet?.defaultChain ?? wallet?.chains[0];
   }
 
   if (!wallet) return null;
@@ -284,14 +391,20 @@ export async function getWalletAddress(method?: string): Promise<string | null>
   // OWS-managed wallet: derive address via the adapter
   if (wallet.keyType === "ows" && wallet.owsWalletId) {
     try {
-      const { owsAccountFromWalletId } = await import("./ows-adapter.js");
-      const account = await owsAccountFromWalletId(wallet.owsWalletId);
-      return account.address;
+      const { getOwsWalletAddress } = await import("./ows-adapter.js");
+      return await getOwsWalletAddress(
+        wallet.owsWalletId,
+        chain === "solana" ? "solana" : "evm",
+      );
     } catch {
       return null;
     }
   }
 
+  if (chain === "solana") {
+    return null;
+  }
+
   // Raw EVM key path
   if (!wallet.key) return null;
 

package/src/core/principal.ts

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

package/src/core/solana-charge.ts

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

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/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;
@@ -22,6 +21,16 @@ export interface AgentRecord {
   };
   payment?: {
     pricing?: Record<string, unknown>;
+    accepted_payments?: string[];
+    credit_packs?: {
+      unit_type?: string;
+      packs?: Array<{
+        key?: string;
+        name?: string;
+        included_units?: number;
+        price_usd?: string;
+      }>;
+    } | null;
     [key: string]: unknown;
   };
   [key: string]: unknown;

package/src/index.ts

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