@agentwonderland/mcp 0.1.24 → 0.1.26

package/dist/core/formatters.d.ts

@@ -11,7 +11,7 @@ export declare function isFileOutput(output: unknown): output is {
     mime_type?: string;
     size_bytes?: number;
 };
-export declare function formatPrice(pricePer1kTokens?: string | null, pricingModel?: string | null): string;
+export declare function formatPrice(pricePerRunUsd?: string | null): string;
 interface AgentLike {
     id?: string;
     name?: string;
@@ -19,8 +19,7 @@ interface AgentLike {
     avgRating?: number | null;
     ratingCount?: number;
     totalExecutions?: number;
-    pricePer1kTokens?: string;
-    pricingModel?: string;
+    pricePerRunUsd?: string;
     stats?: {
         completedJobs?: number;
         avgRating?: number | null;
@@ -39,8 +38,9 @@ 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;

package/dist/core/formatters.js

@@ -32,20 +32,18 @@ export function isFileOutput(output) {
     return output != null && typeof output === "object" && output.type === "file" && !!output.url;
 }
 // ── Price formatting ─────────────────────────────────────────────
-export function formatPrice(pricePer1kTokens, pricingModel) {
-    if (!pricePer1kTokens)
+export function formatPrice(pricePerRunUsd) {
+    if (!pricePerRunUsd)
         return "free";
-    const p = parseFloat(pricePer1kTokens);
-    if (pricingModel === "fixed")
-        return `$${p.toFixed(2)}/req`;
-    return `$${p.toFixed(3)}/1k tokens`;
+    const p = parseFloat(pricePerRunUsd);
+    return `$${p.toFixed(2)}/req`;
 }
 export function agentLine(agent) {
     const name = agent.name ?? "Unknown";
     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`
         : "";
@@ -83,6 +81,12 @@ export function agentList(agents, query) {
     const lines = agents.map((a) => `  ${agentLine(a)}`);
     return [header, "", ...lines].join("\n");
 }
+function toDisplayCost(value) {
+    if (value == null)
+        return null;
+    const numeric = typeof value === "number" ? value : Number.parseFloat(value);
+    return Number.isFinite(numeric) ? numeric : null;
+}
 export function formatRunResult(result, opts) {
     const lines = [];
     // Output
@@ -109,7 +113,7 @@ export function formatRunResult(result, opts) {
         lines.push("");
     }
     // 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/dist/core/passes.d.ts

@@ -34,7 +34,7 @@ export interface CreditPackInventory {
     balances: CreditPackRecord[];
 }
 export declare function getCreditPackProgram(agent: AgentRecord): CreditPackProgramInfo | null;
-export declare function getCreditPackInventory(agentId: string): Promise<CreditPackInventory | null>;
+export declare function getCreditPackInventory(agentId: string, method?: string): Promise<CreditPackInventory | null>;
 export declare function getActiveCreditPack(inventory: CreditPackInventory | null): CreditPackRecord | null;
 export declare function formatCreditPackOffer(offer: CreditPackOffer): string;
 export declare function formatCreditPack(pack: CreditPackRecord): string;

package/dist/core/passes.js

@@ -4,9 +4,12 @@ export function getCreditPackProgram(agent) {
     const creditPacks = payment.credit_packs;
     return creditPacks ?? null;
 }
-export async function getCreditPackInventory(agentId) {
+export async function getCreditPackInventory(agentId, method) {
     try {
-        return await apiGet(`/agents/${agentId}/credit-packs`, { ensureConsumerPrincipal: true });
+        return await apiGet(`/agents/${agentId}/credit-packs`, {
+            ensureConsumerPrincipal: true,
+            principalMethod: method,
+        });
     }
     catch {
         return null;

package/dist/core/payments.d.ts

@@ -10,6 +10,7 @@
  * which to use per-request via `--pay-with <wallet-id|chain|card>`.
  */
 import type { AgentRecord } from "./types.js";
+export declare function isCardPaymentEnabled(): boolean;
 /**
  * Returns a payment-aware fetch for a specific method, or the best
  * available method if none is specified.

package/dist/core/payments.js

@@ -10,6 +10,13 @@
  * which to use per-request via `--pay-with <wallet-id|chain|card>`.
  */
 import { getConfig, getWallets, getDefaultWallet, getCardConfig, resolveWalletAndChain, getApiUrl, } from "./config.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() {
+    return ENABLE_CARD_PAYMENT;
+}
 // Cache per wallet+chain combo to avoid re-initializing
 const fetchCache = new Map();
 const REGISTRY_METHOD_MAP = {
@@ -45,9 +52,9 @@ function clearStaleCardCache(activeKey) {
     }
 }
 // ── Per-protocol initializers ───────────────────────────────────
-async function initMpp(wallet) {
+async function initEvmMppForChain(wallet, chain) {
     try {
-        const { Mppx, tempo } = await import("mppx/client");
+        const { Mppx } = await import("mppx/client");
         let account;
         if (wallet.keyType === "ows" && wallet.owsWalletId) {
             const { owsAccountFromWalletId } = await import("./ows-adapter.js");
@@ -60,8 +67,16 @@ async function initMpp(wallet) {
         else {
             return null;
         }
-        const { baseChargeClient } = await import("./base-charge.js");
-        const mppx = Mppx.create({ methods: [tempo({ account }), baseChargeClient({ account })] });
+        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, polyfill: false });
         return mppx.fetch.bind(mppx);
     }
     catch {
@@ -77,6 +92,7 @@ async function initSolanaMpp(wallet) {
         const { solanaChargeClient } = await import("./solana-charge.js");
         const mppx = Mppx.create({
             methods: [solanaChargeClient({ wallet })],
+            polyfill: false,
         });
         return mppx.fetch.bind(mppx);
     }
@@ -113,6 +129,7 @@ async function initCard() {
                         return spt;
                     },
                 })],
+            polyfill: false,
         });
         return mppx.fetch.bind(mppx);
     }
@@ -127,7 +144,10 @@ async function initForChain(wallet, chain) {
     if (chain === "solana") {
         return initSolanaMpp(wallet);
     }
-    return initMpp(wallet);
+    if (chain === "tempo" || chain === "base") {
+        return initEvmMppForChain(wallet, chain);
+    }
+    return null;
 }
 // ── Public API ──────────────────────────────────────────────────
 /**
@@ -139,6 +159,9 @@ async function initForChain(wallet, chain) {
 export async function getPaymentFetch(method) {
     // 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) {
@@ -247,13 +270,13 @@ export function getConfiguredMethods() {
                 methods.push(c);
         }
     }
-    // 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/dist/core/principal.d.ts

@@ -1,2 +1,5 @@
 export declare function getConsumerPrincipal(): Promise<string | null>;
+export declare function getBaseRebatePrincipal(): Promise<string | null>;
+export declare function getConsumerPrincipalForMethod(method?: string): Promise<string | null>;
 export declare function ensureConsumerPrincipal(): Promise<string>;
+export declare function ensureConsumerPrincipalForMethod(method?: string): Promise<string>;

package/dist/core/principal.js

@@ -1,4 +1,4 @@
-import { addWallet, getDefaultWallet, getWallets } from "./config.js";
+import { addWallet, getDefaultWallet, getWallets, resolveWalletAndChain, } from "./config.js";
 import { getWalletAddress } from "./payments.js";
 import { createOwsWallet, isOwsAvailable, listOwsWallets, } from "./ows-adapter.js";
 const BASE_CHAIN_ID = "8453";
@@ -27,6 +27,12 @@ async function walletPrincipal(wallet) {
     }
     return null;
 }
+async function principalForChain(chain) {
+    const address = await getWalletAddress(chain);
+    if (!address)
+        return null;
+    return principalFromAddress(address, chain === "solana" ? "solana" : "evm");
+}
 function preferredWallets() {
     const wallets = getWallets();
     const defaultWallet = getDefaultWallet();
@@ -96,6 +102,18 @@ export async function getConsumerPrincipal() {
     }
     return null;
 }
+export async function getBaseRebatePrincipal() {
+    return (await principalForChain("base")) ?? principalForChain("tempo");
+}
+export async function getConsumerPrincipalForMethod(method) {
+    if (!method || method === "card") {
+        return getConsumerPrincipal();
+    }
+    const resolved = resolveWalletAndChain(method);
+    if (!resolved)
+        return null;
+    return principalForChain(resolved.chain);
+}
 export async function ensureConsumerPrincipal() {
     const existing = await getConsumerPrincipal();
     if (existing)
@@ -107,3 +125,13 @@ export async function ensureConsumerPrincipal() {
     }
     return principal;
 }
+export async function ensureConsumerPrincipalForMethod(method) {
+    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/dist/core/settings.d.ts

@@ -0,0 +1,20 @@
+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";
+        };
+    };
+}
+export declare function getSettings(): Promise<PublicSettings | null>;

package/dist/core/settings.js

@@ -0,0 +1,19 @@
+import { getApiUrl } from "./config.js";
+let cache = null;
+const TTL_MS = 5 * 60 * 1000;
+export async function getSettings() {
+    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();
+        cache = { data, expiresAt: now + TTL_MS };
+        return data;
+    }
+    catch {
+        return cache?.data ?? null;
+    }
+}

package/dist/core/solana-charge.d.ts

@@ -1,3 +1,4 @@
+import { Connection, PublicKey } from "@solana/web3.js";
 import type { WalletEntry } from "./config.js";
 export declare const SOLANA_USDC_MINT: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
 export declare const SOLANA_CHAIN_ID: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
@@ -5,5 +6,9 @@ interface SolanaChargeClientConfig {
     wallet: WalletEntry;
     rpcUrl?: string;
 }
+export declare function resolveRecipientTokenAccount(connection: Connection, mint: PublicKey, recipient: PublicKey): Promise<{
+    tokenAccount: PublicKey;
+    needsCreateAssociatedAccount: boolean;
+}>;
 export declare function solanaChargeClient(config: SolanaChargeClientConfig): any;
 export {};

package/dist/core/solana-charge.js

@@ -6,7 +6,8 @@
  */
 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 { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID, createAssociatedTokenAccountInstruction, createTransferCheckedInstruction, getAssociatedTokenAddressSync, } from "@solana/spl-token";
+import { toAtomicAmount } from "./amount-utils.js";
 export const SOLANA_USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
 export const SOLANA_CHAIN_ID = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
 const SOLANA_RPC = "https://api.mainnet-beta.solana.com";
@@ -55,19 +56,34 @@ async function getKeypair(wallet) {
     }
     throw new Error(`Wallet "${wallet.id}" cannot sign Solana transactions.`);
 }
-async function resolveRecipientTokenAccount(connection, mint, recipient) {
+export async function resolveRecipientTokenAccount(connection, mint, recipient) {
     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(mint, recipient, false, TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID);
+    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) {
     return Method.toClient(solanaChargeMethod, {
         async createCredential({ challenge }) {
             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);
@@ -75,13 +91,20 @@ export function solanaChargeClient(config) {
             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 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));
+            }
+            instructions.push(createTransferCheckedInstruction(sourceTokenAccount, mint, 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/dist/core/spend-policy.d.ts

@@ -0,0 +1,12 @@
+export declare function getDailySpend(method: string, now?: Date): number;
+export declare function canSpend(params: {
+    method: string;
+    amountUsd: number;
+}): {
+    ok: true;
+} | {
+    ok: false;
+    message: string;
+};
+export declare function requiresPolicyConfirmation(method: string, amountUsd: number): boolean;
+export declare function recordSpend(method: string, amountUsd: number, now?: Date): void;

package/dist/core/spend-policy.js

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

package/dist/core/tempo-charge.d.ts

@@ -0,0 +1,7 @@
+import type { LocalAccount } from "viem/accounts";
+interface TempoChargeClientConfig {
+    account: LocalAccount;
+    rpcUrl?: string;
+}
+export declare function tempoChargeClient(config: TempoChargeClientConfig): any;
+export {};

package/dist/core/tempo-charge.js

@@ -0,0 +1,84 @@
+/**
+ * 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 { toAtomicAmount } from "./amount-utils.js";
+const TEMPO_USDC = "0x20c000000000000000000000b9537d11c60e8b50";
+const PATH_USD = "0x20c0000000000000000000000000000000000000";
+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",
+    },
+];
+const tempoChargeMethod = Method.from({
+    name: "tempo",
+    intent: "charge",
+    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) => ({
+            ...v,
+            methodDetails: {
+                chainId: v.chainId ?? TEMPO_MAINNET_CHAIN_ID,
+            },
+        }))),
+    },
+});
+export function tempoChargeClient(config) {
+    return Method.toClient(tempoChargeMethod, {
+        async createCredential({ challenge }) {
+            const { request } = challenge;
+            const amount = toAtomicAmount(request.amount, request.decimals ?? 6);
+            const recipient = request.recipient;
+            const currency = (request.currency ?? TEMPO_USDC);
+            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" },
+                source: `did:pkh:eip155:${chainId}:${config.account.address}`,
+            });
+        },
+    });
+}

package/dist/core/types.d.ts

@@ -5,8 +5,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/dist/index.js

@@ -12,6 +12,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";
 import { registerWalletResources } from "./resources/wallet.js";
@@ -39,12 +40,14 @@ export async function startMcpServer() {
             "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.",
@@ -70,6 +73,7 @@ export async function startMcpServer() {
     registerFavoriteTools(server);
     registerTipTools(server);
     registerPassTools(server);
+    registerObservabilityTools(server);
     // Register resources
     registerAgentResources(server);
     registerWalletResources(server);

package/dist/prompts/index.js

@@ -12,7 +12,7 @@ export function registerPrompts(server) {
                         "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"),
                 },
             }],
@@ -62,7 +62,7 @@ export function registerPrompts(server) {
                     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"),
                 },
             }],
@@ -78,6 +78,8 @@ export function registerPrompts(server) {
                     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/dist/resources/agents.js

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

package/dist/tools/__tests__/jobs.test.d.ts

@@ -0,0 +1 @@
+export {};