@agentwonderland/mcp 0.1.25 → 0.1.27

package/dist/tools/__tests__/wallet.test.js

@@ -0,0 +1,230 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+const state = vi.hoisted(() => ({
+    wallets: [],
+    addedWallets: [],
+    card: null,
+    pendingCardSetupToken: null,
+    spendPolicies: {},
+    consumerPrincipal: "did:pkh:eip155:8453:0xabc",
+    owsAvailable: true,
+    owsWallets: [],
+    owsWalletsByChain: [],
+    createdWalletCalls: [],
+    importWalletCalls: [],
+    createdWalletResult: {
+        walletId: "ows-wallet-created",
+        address: "0x1111111111111111111111111111111111111111",
+    },
+    importWalletResult: {
+        walletId: "ows-wallet-imported",
+        address: "0x2222222222222222222222222222222222222222",
+    },
+    cardSetup: {
+        url: "https://api.agentwonderland.com/card/handoff/setup-token",
+        token: "setup-token",
+        isNew: true,
+    },
+    cardSetupBlocks: [
+        "Open this setup page to connect your card:\n\nhttps://api.agentwonderland.com/card/handoff/setup-token",
+    ],
+    pollCardSetupCalls: [],
+    pollCardSetupResult: null,
+    setCardConfigCalls: [],
+}));
+vi.mock("../../core/config.js", () => ({
+    addWallet: (wallet) => {
+        state.addedWallets.push(wallet);
+        const existing = state.wallets.findIndex((entry) => entry.id === wallet.id);
+        if (existing >= 0) {
+            state.wallets[existing] = wallet;
+        }
+        else {
+            state.wallets.push(wallet);
+        }
+    },
+    getCardConfig: () => state.card,
+    getPendingCardSetupToken: () => state.pendingCardSetupToken,
+    getSpendPolicy: (walletId) => state.spendPolicies[walletId] ?? null,
+    getWallets: () => state.wallets,
+    setCardConfig: (card) => {
+        state.card = card;
+        state.setCardConfigCalls.push(card);
+    },
+    setSpendPolicy: (walletId, policy) => {
+        state.spendPolicies[walletId] = policy;
+    },
+}));
+vi.mock("../../core/payments.js", () => ({
+    getWalletAddress: async () => null,
+}));
+vi.mock("../../core/card-setup.js", () => ({
+    formatCardSetupBlocks: () => state.cardSetupBlocks,
+    getCardCapabilities: async () => ({
+        spt_status: "enabled",
+    }),
+    getOrCreatePendingCardSetup: async () => state.cardSetup,
+    pollCardSetup: async (token, timeoutMs) => {
+        state.pollCardSetupCalls.push({ token, timeoutMs });
+        return state.pollCardSetupResult;
+    },
+}));
+vi.mock("../../core/ows-adapter.js", () => ({
+    createOwsWallet: async (name, chain) => {
+        state.createdWalletCalls.push({ name, chain });
+        return state.createdWalletResult;
+    },
+    importKeyToOws: async (privateKey, name, chain) => {
+        state.importWalletCalls.push({ privateKey, name, chain });
+        return state.importWalletResult;
+    },
+    isOwsAvailable: async () => state.owsAvailable,
+    listOwsWallets: async () => state.owsWallets,
+    listOwsWalletsByChain: async () => state.owsWalletsByChain,
+}));
+vi.mock("../../core/principal.js", () => ({
+    ensureConsumerPrincipal: async () => state.consumerPrincipal,
+    getConsumerPrincipal: async () => state.consumerPrincipal,
+}));
+function resetState() {
+    state.wallets = [];
+    state.addedWallets = [];
+    state.card = null;
+    state.pendingCardSetupToken = null;
+    state.spendPolicies = {};
+    state.consumerPrincipal = "did:pkh:eip155:8453:0xabc";
+    state.owsAvailable = true;
+    state.owsWallets = [];
+    state.owsWalletsByChain = [];
+    state.createdWalletCalls = [];
+    state.importWalletCalls = [];
+    state.createdWalletResult = {
+        walletId: "ows-wallet-created",
+        address: "0x1111111111111111111111111111111111111111",
+    };
+    state.importWalletResult = {
+        walletId: "ows-wallet-imported",
+        address: "0x2222222222222222222222222222222222222222",
+    };
+    state.cardSetup = {
+        url: "https://api.agentwonderland.com/card/handoff/setup-token",
+        token: "setup-token",
+        isNew: true,
+    };
+    state.cardSetupBlocks = [
+        "Open this setup page to connect your card:\n\nhttps://api.agentwonderland.com/card/handoff/setup-token",
+    ];
+    state.pollCardSetupCalls = [];
+    state.pollCardSetupResult = null;
+    state.setCardConfigCalls = [];
+}
+async function getWalletSetupTool() {
+    const tools = new Map();
+    const server = {
+        tool: (name, _description, _schema, handler) => {
+            tools.set(name, handler);
+        },
+    };
+    const { registerWalletTools } = await import("../wallet.js");
+    registerWalletTools(server);
+    const walletSetup = tools.get("wallet_setup");
+    if (!walletSetup) {
+        throw new Error("wallet_setup tool was not registered");
+    }
+    return walletSetup;
+}
+function flattenText(result) {
+    return result.content.map((item) => item.text).join("\n");
+}
+describe("wallet_setup tool", () => {
+    beforeEach(() => {
+        vi.resetModules();
+        resetState();
+    });
+    it("creates an encrypted OWS wallet for Tempo/Base with Base as the default chain", async () => {
+        const walletSetup = await getWalletSetupTool();
+        const result = await walletSetup({ action: "create", name: "launch-wallet", chain: "base" });
+        const text = flattenText(result);
+        expect(state.createdWalletCalls).toEqual([
+            { name: "launch-wallet", chain: "evm" },
+        ]);
+        expect(state.addedWallets).toEqual([
+            {
+                id: "launch-wallet",
+                keyType: "ows",
+                owsWalletId: "ows-wallet-created",
+                chains: ["tempo", "base"],
+                defaultChain: "base",
+                label: "launch-wallet",
+            },
+        ]);
+        expect(text).toContain("Wallet created [encrypted]:");
+        expect(text).toContain("Address: 0x1111111111111111111111111111111111111111");
+        expect(text).toContain("Chains: tempo, base");
+        expect(text).toContain("Consumer principal: did:pkh:eip155:8453:0xabc");
+    });
+    it("imports a wallet into OWS encrypted storage with Base as the default chain", async () => {
+        const walletSetup = await getWalletSetupTool();
+        const result = await walletSetup({
+            action: "import",
+            key: "0x1234",
+            name: "imported-wallet",
+            chain: "base",
+        });
+        const text = flattenText(result);
+        expect(state.importWalletCalls).toEqual([
+            { privateKey: "0x1234", name: "imported-wallet", chain: "evm" },
+        ]);
+        expect(state.addedWallets).toEqual([
+            {
+                id: "imported-wallet",
+                keyType: "ows",
+                owsWalletId: "ows-wallet-imported",
+                chains: ["tempo", "base"],
+                defaultChain: "base",
+                label: "imported-wallet",
+            },
+        ]);
+        expect(text).toContain("Key imported to OWS [encrypted]:");
+        expect(text).toContain("Address: 0x2222222222222222222222222222222222222222");
+        expect(text).toContain("Consumer principal: did:pkh:eip155:8453:0xabc");
+    });
+    it("starts card setup when no card is connected", async () => {
+        const walletSetup = await getWalletSetupTool();
+        const result = await walletSetup({ action: "add-card" });
+        const text = flattenText(result);
+        expect(text).toContain("Open this setup page to connect your card:");
+        expect(text).toContain("https://api.agentwonderland.com/card/handoff/setup-token");
+        expect(state.pollCardSetupCalls).toEqual([]);
+    });
+    it("completes a pending card setup when Stripe handoff has finished", async () => {
+        state.pendingCardSetupToken = "setup-token";
+        state.pollCardSetupResult = {
+            brand: "Visa",
+            last4: "4242",
+            consumerToken: "consumer-token",
+        };
+        const walletSetup = await getWalletSetupTool();
+        const result = await walletSetup({ action: "add-card" });
+        const text = flattenText(result);
+        expect(state.pollCardSetupCalls).toEqual([
+            { token: "setup-token", timeoutMs: 250 },
+        ]);
+        expect(text).toContain("Connected! Visa ****4242 is ready for payments.");
+        expect(text).toContain("Consumer principal: did:pkh:eip155:8453:0xabc");
+    });
+    it("removes the connected card", async () => {
+        state.card = {
+            consumerToken: "consumer-token",
+            paymentMethodId: "pm_123",
+            last4: "4242",
+            brand: "Visa",
+        };
+        const walletSetup = await getWalletSetupTool();
+        const result = await walletSetup({ action: "remove-card" });
+        const text = flattenText(result);
+        expect(state.setCardConfigCalls).toEqual([null]);
+        expect(state.card).toBeNull();
+        expect(text).toContain("Removed Visa ****4242.");
+        expect(text).toContain("Card disconnected from Agent Wonderland.");
+    });
+});

package/dist/tools/_payment-confirmation.js

@@ -23,6 +23,6 @@ export function formatPaymentChoicePrompt(subject, methods, commands) {
         ...commands,
         "",
         `Available methods: ${methods.map((method) => `"${method}"`).join(", ")}`,
-        "For fully agentic execution, include pay_with explicitly.",
+        "You can omit pay_with to use the default compatible method.",
     ].join("\n");
 }

package/dist/tools/agent-info.js

@@ -14,14 +14,26 @@ export function registerAgentInfoTools(server) {
         const payment = (a.payment ?? {});
         const _pricing = (payment.pricing ?? {});
         const creditPacks = payment.credit_packs;
+        const totalJobs = (s.completedJobs ?? a.totalExecutions ?? 0);
+        const acceptedPayments = payment.accepted_payments ?? [];
+        const paymentLabelMap = {
+            tempo_usdc: "tempo",
+            base_usdc: "base",
+            solana_usdc: "solana",
+            stripe_card: "card",
+        };
+        const paymentLabels = acceptedPayments.map((m) => paymentLabelMap[m] ?? m);
         const lines = [
             `${a.name}`,
-            `${stars(a.avgRating ?? s.avgRating)} (${s.ratingCount ?? 0} reviews) • ${compactNumber((s.completedJobs ?? a.totalExecutions ?? 0))} jobs`,
+            `${stars(a.avgRating ?? s.avgRating)} (${s.ratingCount ?? 0} reviews) • ${compactNumber(totalJobs)} jobs`,
             "",
             a.description ?? "",
             "",
             `Pricing: ${formatPrice(a.pricePerRunUsd)}`,
-            `Reliability: ${a.successRate != null ? (Number(a.successRate) * 100).toFixed(0) + "%" : "N/A"}`,
+            ...(paymentLabels.length > 0 ? [`Accepted payments: ${paymentLabels.join(", ")}`] : []),
+            ...(totalJobs > 0 && a.successRate != null
+                ? [`Reliability: ${(Number(a.successRate) * 100).toFixed(0)}% (${compactNumber(totalJobs)} runs)`]
+                : []),
             `Avg latency: ${a.avgResponseTimeMs != null ? a.avgResponseTimeMs + "ms" : "N/A"}`,
             ...(() => {
                 const lastActive = formatLastActive(a.lastActiveAt);
@@ -82,30 +94,4 @@ export function registerAgentInfoTools(server) {
         lines.push("", `ID: ${a.id}`, `View: ${agentWebUrl(a.id)}`);
         return text(lines.join("\n"));
     });
-    // ── compare_agents ──────────────────────────────────────────────
-    server.tool("compare_agents", "Compare multiple agents side-by-side on rating, price, success rate, and job count.", {
-        agent_ids: z
-            .array(z.string())
-            .min(2)
-            .max(5)
-            .describe("Agent IDs to compare (2-5)"),
-    }, async ({ agent_ids }) => {
-        const agents = await Promise.all(agent_ids.map((id) => apiGet(`/agents/${id}`)));
-        const header = "Agent Comparison:\n";
-        const lines = agents.map((a) => {
-            const s = (a.stats ?? {});
-            const rating = a.avgRating ?? s.avgRating;
-            const jobs = (s.completedJobs ?? a.totalExecutions ?? 0);
-            const tipCount = (s.tipCount ?? 0);
-            return [
-                `  ${a.name}`,
-                `  ${stars(rating)} (${s.ratingCount ?? 0} reviews)${tipCount > 0 ? ` • ${tipCount} tips` : ""}`,
-                `  ${compactNumber(jobs)} jobs • ${formatPrice(a.pricePerRunUsd)}`,
-                `  Success: ${a.successRate != null ? (Number(a.successRate) * 100).toFixed(0) + "%" : "N/A"}`,
-                `  ${agentWebUrl(a.id)}`,
-                "",
-            ].join("\n");
-        });
-        return text(header + lines.join("\n"));
-    });
 }

package/dist/tools/jobs.js

@@ -6,32 +6,93 @@ import { formatRunResult } from "../core/formatters.js";
 function text(t) {
     return { content: [{ type: "text", text: t }] };
 }
+async function getConsumerWalletAddresses() {
+    const addresses = new Set();
+    for (const chain of ["tempo", "base", "solana"]) {
+        const addr = await getWalletAddress(chain);
+        if (addr)
+            addresses.add(addr);
+    }
+    return [...addresses];
+}
+function formatRelativeTime(iso) {
+    if (!iso)
+        return "";
+    const t = new Date(iso).getTime();
+    if (!Number.isFinite(t))
+        return "";
+    const diffSec = Math.max(0, Math.floor((Date.now() - t) / 1000));
+    if (diffSec < 60)
+        return `${diffSec}s ago`;
+    if (diffSec < 3600)
+        return `${Math.floor(diffSec / 60)}m ago`;
+    if (diffSec < 86400)
+        return `${Math.floor(diffSec / 3600)}h ago`;
+    return `${Math.floor(diffSec / 86400)}d ago`;
+}
 export function registerJobTools(server) {
     // ── get_job ─────────────────────────────────────────────────────
     server.tool("get_job", "Get the status and output of a job by ID. Use to poll async jobs until they complete.", {
         job_id: z.string().describe("Job ID (UUID)"),
     }, async ({ job_id }) => {
-        const result = await apiGet(`/jobs/${job_id}`);
+        const walletLookup = !isAuthenticated() && hasWalletConfigured();
+        const addresses = walletLookup ? await getConsumerWalletAddresses() : [""];
+        let result = null;
+        for (const addr of addresses) {
+            const url = addr ? `/jobs/${job_id}?wallet=${encodeURIComponent(addr)}` : `/jobs/${job_id}`;
+            try {
+                result = await apiGet(url);
+                break;
+            }
+            catch (err) {
+                const status = err.status;
+                if (status !== 404)
+                    throw err;
+            }
+        }
+        if (!result) {
+            return text(`Job ${job_id} not found. Either the job ID is wrong or it was paid with a wallet not configured here.`);
+        }
         if (result.status === "processing") {
             return text(`Job ${job_id} is still processing...`);
         }
         return text(formatRunResult(result));
     });
-    // ── list_jobs (renamed from list_my_jobs) ───────────────────────
-    server.tool("list_jobs", "List your recent jobs with status, cost, and agent info.", {
-        limit: z.coerce.number().optional().default(10).describe("Max results (1-50)"),
+    // ── list_jobs ───────────────────────────────────────────────────
+    server.tool("list_jobs", "List your recent jobs across all configured payment wallets, with status, cost, agent, method, and age.", {
+        limit: z.coerce.number().int().min(1).max(50).optional().default(10).describe("Max results (1-50)"),
     }, async ({ limit }) => {
-        let url = `/jobs?limit=${limit ?? 10}`;
-        // If not authenticated via API key, use wallet address for lookup
-        if (!isAuthenticated() && hasWalletConfigured()) {
-            const address = await getWalletAddress();
-            if (address) {
-                url += `&wallet=${encodeURIComponent(address)}`;
+        const requestedLimit = limit ?? 10;
+        const walletLookup = !isAuthenticated() && hasWalletConfigured();
+        const addresses = walletLookup ? await getConsumerWalletAddresses() : [""];
+        const seen = new Set();
+        const collected = [];
+        for (const addr of addresses) {
+            const url = addr
+                ? `/jobs?wallet=${encodeURIComponent(addr)}&limit=${requestedLimit}`
+                : `/jobs?limit=${requestedLimit}`;
+            try {
+                const jobs = await apiGet(url);
+                for (const j of jobs) {
+                    const id = j.job_id;
+                    if (!seen.has(id)) {
+                        seen.add(id);
+                        collected.push(j);
+                    }
+                }
+            }
+            catch {
+                // Skip address that errored; continue with others.
             }
         }
-        const jobs = await apiGet(url);
-        if (jobs.length === 0)
+        if (collected.length === 0)
             return text("No jobs found.");
+        collected.sort((a, b) => {
+            const aTime = new Date(a.created_at ?? 0).getTime();
+            const bTime = new Date(b.created_at ?? 0).getTime();
+            return bTime - aTime;
+        });
+        const jobs = collected.slice(0, requestedLimit);
         const lines = [`Recent jobs (${jobs.length}):`];
         for (const j of jobs) {
             const status = j.status === "completed"
@@ -39,10 +100,15 @@ export function registerJobTools(server) {
                 : j.status === "processing"
                     ? "\u2026"
                     : "\u2717";
-            const cost = j.estimated_cost != null
-                ? `$${Number(j.estimated_cost).toFixed(4)}`
-                : "";
-            lines.push(`  ${status} ${j.job_id?.slice(0, 8)}\u2026 ${j.agent_id ? String(j.agent_id).slice(0, 8) + "\u2026" : ""} ${cost}`);
+            const amount = (j.settled_amount ?? j.estimated_cost);
+            const cost = amount != null ? `$${Number(amount).toFixed(4)}` : "";
+            const method = j.settlement_trace
+                ?.payment_attempt?.payment_method;
+            const methodLabel = method ? `[${method.replace(/_usdc$/, "").replace("stripe_", "")}]` : "";
+            const shortId = j.job_id?.slice(0, 8);
+            const shortAgent = j.agent_id ? String(j.agent_id).slice(0, 8) : "?";
+            const when = formatRelativeTime(j.created_at);
+            lines.push(`  ${status} ${shortId} agent=${shortAgent} ${cost} ${methodLabel} ${when}`.trimEnd());
         }
         return text(lines.join("\n"));
     });

package/dist/tools/passes.js

@@ -1,9 +1,9 @@
 import { z } from "zod";
 import { apiGet, apiPostWithPayment } from "../core/api-client.js";
-import { formatCreditPack, formatCreditPackOffer, getCreditPackProgram, } from "../core/passes.js";
-import { getCompatiblePaymentMethods, getConfiguredMethods, hasWalletConfigured, normalizePaymentMethod, } from "../core/payments.js";
+import { formatCreditPack, formatCreditPackOffer, getCreditPackInventory, getCreditPackProgram, } from "../core/passes.js";
+import { getCompatiblePaymentMethods, getConfiguredMethods, hasWalletConfigured, normalizePaymentMethod, isCardPaymentEnabled, } from "../core/payments.js";
 import { requiresSpendConfirmation } from "../core/config.js";
-import { ensureConsumerPrincipal } from "../core/principal.js";
+import { ensureConsumerPrincipalForMethod } from "../core/principal.js";
 import { getOrCreatePendingCardSetup, formatCardSetupBlocks } from "../core/card-setup.js";
 import { formatPaymentChoicePrompt, formatPaymentLabel, resolveConfirmationMethod, } from "./_payment-confirmation.js";
 const pendingCreditPackPurchases = new Map();
@@ -39,19 +39,29 @@ export function registerPassTools(server) {
         confirmed: z.boolean().optional().describe("Set to true to confirm the purchase after seeing the quote."),
     }, async ({ agent_id, pack_id, pay_with, confirmed }) => {
         if (!hasWalletConfigured()) {
-            try {
-                const { url } = await getOrCreatePendingCardSetup();
-                return multiText(...formatCardSetupBlocks(url));
+            if (isCardPaymentEnabled()) {
+                try {
+                    const { url } = await getOrCreatePendingCardSetup();
+                    return multiText(...formatCardSetupBlocks(url));
+                }
+                catch {
+                    // Fall through to the setup message below.
+                }
             }
-            catch {
-                return text("No payment method configured.\n\n" +
-                    "To add a credit card: wallet_setup({ action: \"add-card\" })\n" +
-                    "To use crypto: wallet_setup({ action: \"create\" })");
+            const setupLines = [
+                "No payment method configured.",
+                "",
+                "Supported rails: Tempo USDC, Base USDC, Solana USDC.",
+                "Run wallet_setup({ action: \"create\" }) to create a crypto wallet,",
+                "or wallet_setup({ action: \"import\" }) with an existing key.",
+            ];
+            if (isCardPaymentEnabled()) {
+                setupLines.push("", "Or wallet_setup({ action: \"add-card\" }) to connect a credit card.");
             }
+            return text(setupLines.join("\n"));
         }
         const agent = await getAgent(agent_id);
         const agentName = agent.name ?? agent_id;
-        const principal = await ensureConsumerPrincipal();
         const program = getCreditPackProgram(agent);
         const offers = (program?.packs ?? [])
             .map((pack) => findOffer(agent, pack.key ?? ""))
@@ -102,6 +112,7 @@ export function registerPassTools(server) {
             ].join("\n"));
         }
         const method = resolveConfirmationMethod(pay_with, pending?.method, compatibleMethods);
+        const principal = await ensureConsumerPrincipalForMethod(method);
         if (requiresSpendConfirmation() && !confirmed) {
             pendingCreditPackPurchases.set(agent.id, {
                 agentId: agent.id,
@@ -131,14 +142,19 @@ export function registerPassTools(server) {
             formatCreditPack(result.credit_pack),
             `Consumer principal: ${result.consumer_principal}`,
             "",
-            "Future runs through run_agent will automatically use this credit pack while units remain.",
+            "Future runs for this agent will automatically use this credit pack while units remain.",
+            "That includes run_agent, and solve whenever it selects this same agent.",
         ].join("\n"));
     });
     server.tool("list_agent_credit_packs", "Show discounted credit-pack offers for an agent plus any balances available under the current consumer principal.", {
         agent_id: z.string().describe("Agent ID (UUID, slug, or name)"),
-    }, async ({ agent_id }) => {
+        pay_with: z.string().optional().describe("Optional payment method context used to inspect the matching consumer principal."),
+    }, async ({ agent_id, pay_with }) => {
         const agent = await getAgent(agent_id);
-        const result = await apiGet(`/agents/${agent.id}/credit-packs`, { ensureConsumerPrincipal: true });
+        const result = await getCreditPackInventory(agent.id, pay_with);
+        if (!result) {
+            return text(`Could not load credit-pack inventory for ${agent.name}.`);
+        }
         const lines = [
             `Credit packs for ${agent.name}`,
             ...(result.consumer_principal ? [`Consumer principal: ${result.consumer_principal}`] : []),

package/dist/tools/run.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { apiGet, apiPost, apiPostWithPayment } from "../core/api-client.js";
 import { uploadLocalFiles } from "../core/file-upload.js";
 import { formatCreditPackOffer, getActiveCreditPack, getCreditPackInventory, getCreditPackProgram, } from "../core/passes.js";
-import { getCompatiblePaymentMethods, getConfiguredMethods, hasWalletConfigured, getWalletAddress, normalizePaymentMethod, } from "../core/payments.js";
+import { getCompatiblePaymentMethods, getConfiguredMethods, hasWalletConfigured, getWalletAddress, normalizePaymentMethod, isCardPaymentEnabled, } from "../core/payments.js";
 import { requiresSpendConfirmation, getDefaultTipAmount } from "../core/config.js";
 import { formatRunResult } from "../core/formatters.js";
 import { canSpend, recordSpend, requiresPolicyConfirmation } from "../core/spend-policy.js";
@@ -11,9 +11,9 @@ import { getOrCreatePendingCardSetup, formatCardSetupBlocks } from "../core/card
 import { formatPaymentLabel, formatRunConfirmationCommand, resolveConfirmationMethod, } from "./_payment-confirmation.js";
 const POLL_INTERVAL_MS = 3000;
 const POLL_MAX_MS = 120000;
-async function pollJobUntilDone(jobId) {
+async function pollJobUntilDone(jobId, paymentMethod) {
     const deadline = Date.now() + POLL_MAX_MS;
-    const walletAddress = await getWalletAddress();
+    const walletAddress = await getWalletAddress(paymentMethod);
     const walletParam = walletAddress ? `?wallet=${walletAddress}` : "";
     while (Date.now() < deadline) {
         await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
@@ -61,19 +61,30 @@ export function registerRunTools(server) {
     server.tool("run_agent", "Run an AI agent from the marketplace. Pays automatically via configured wallet. Returns the agent's output, cost, and job ID for tracking. If spending confirmation is enabled, first call returns a price quote — call again with confirmed: true to execute. Local file paths in the input (e.g. /Users/.../photo.jpg) are automatically uploaded to temporary storage and replaced with download URLs before execution.", {
         agent_id: z.string().describe("Agent ID (UUID, slug, or name)"),
         input: z.record(z.unknown()).describe("Input payload for the agent"),
-        pay_with: z.string().trim().min(1).describe("Required payment method — wallet ID, chain name (tempo, base, etc.), or 'card'. Use wallet_status to see configured options."),
+        pay_with: z.string().trim().min(1).optional().describe("Payment method — wallet ID, chain name (tempo, base, etc.), or 'card'. Auto-detected if omitted."),
         confirmed: z.boolean().optional().describe("Set to true to confirm spending after seeing the price quote."),
     }, async ({ agent_id, input, pay_with, confirmed }) => {
         if (!hasWalletConfigured()) {
-            try {
-                const { url } = await getOrCreatePendingCardSetup();
-                return multiText(...formatCardSetupBlocks(url));
+            if (isCardPaymentEnabled()) {
+                try {
+                    const { url } = await getOrCreatePendingCardSetup();
+                    return multiText(...formatCardSetupBlocks(url));
+                }
+                catch {
+                    // Fall through to the setup message below.
+                }
             }
-            catch {
-                return text("No payment method configured.\n\n" +
-                    "To add a credit card: wallet_setup({ action: \"add-card\" })\n" +
-                    "To use crypto: wallet_setup({ action: \"create\" })");
+            const setupLines = [
+                "No payment method configured.",
+                "",
+                "Supported rails: Tempo USDC, Base USDC, Solana USDC.",
+                "Run wallet_setup({ action: \"create\" }) to create a crypto wallet,",
+                "or wallet_setup({ action: \"import\" }) with an existing key.",
+            ];
+            if (isCardPaymentEnabled()) {
+                setupLines.push("", "Or wallet_setup({ action: \"add-card\" }) to connect a credit card.");
             }
+            return text(setupLines.join("\n"));
         }
         let agent;
         try {
@@ -84,23 +95,27 @@ export function registerRunTools(server) {
         }
         const price = parseFloat(agent.pricePerRunUsd ?? "0.01");
         const agentName = agent.name ?? agent_id;
-        const creditPackInventory = await getCreditPackInventory(agent.id);
-        const activeCreditPack = getActiveCreditPack(creditPackInventory);
         const compatibleMethods = getCompatiblePaymentMethods(agent, getConfiguredMethods());
         const pending = pendingRuns.get(agent.id);
-        const requestedMethod = pay_with;
-        const normalizedRequestedMethod = normalizePaymentMethod(requestedMethod);
-        if (!normalizedRequestedMethod) {
+        const requestedMethod = pay_with ?? pending?.method;
+        const normalizedRequestedMethod = requestedMethod ? normalizePaymentMethod(requestedMethod) : null;
+        const creditPackInventory = await getCreditPackInventory(agent.id, requestedMethod);
+        const activeCreditPack = getActiveCreditPack(creditPackInventory);
+        if (requestedMethod && !normalizedRequestedMethod) {
             return text(`Payment method "${requestedMethod}" is not configured.\n\n` +
                 "Use wallet_status to review your current payment methods.");
         }
-        if (!compatibleMethods.includes(normalizedRequestedMethod)) {
+        if (normalizedRequestedMethod && !compatibleMethods.includes(normalizedRequestedMethod)) {
             return text(`This agent cannot be paid with "${requestedMethod}".\n\n` +
                 `Available payment methods for this agent: ${compatibleMethods.join(", ") || "none"}.\n` +
                 "Use get_agent to inspect the agent details or choose another payment method.");
         }
-        const method = resolveConfirmationMethod(pay_with, pending?.method, compatibleMethods);
-        const spendCheckMethod = method ?? normalizedRequestedMethod;
+        if (!activeCreditPack && compatibleMethods.length === 0) {
+            return text(`No compatible payment methods are configured for ${agentName}.\n\n` +
+                "Use wallet_status to review your current payment methods.");
+        }
+        const method = resolveConfirmationMethod(requestedMethod, pending?.method, compatibleMethods);
+        const spendCheckMethod = method ?? normalizedRequestedMethod ?? compatibleMethods[0];
         if (!activeCreditPack) {
             const spendCheck = canSpend({
                 method: spendCheckMethod,
@@ -201,7 +216,7 @@ export function registerRunTools(server) {
         const status = result.status;
         const usedCreditPack = result.consumption_mode === "credit_pack";
         if (status === "processing") {
-            const pollResult = await pollJobUntilDone(jobId);
+            const pollResult = await pollJobUntilDone(jobId, method);
             if (pollResult.status === "completed") {
                 const asyncFormatted = formatRunResult({
                     ...result,

package/dist/tools/search.js

@@ -16,14 +16,15 @@ export function registerSearchTools(server) {
         sort: z.enum(["relevance", "price", "rating", "popularity", "newest"]).optional()
             .describe("Sort results by: relevance (default), price, rating, popularity, or newest"),
     }, async ({ query, tag, limit, max_price, min_rating, sort }) => {
-        const requestedLimit = limit ?? 10;
+        const requestedLimit = Math.max(1, Math.min(50, limit ?? 10));
         const params = new URLSearchParams();
         if (query)
             params.set("q", query);
         if (tag)
             params.set("tag", tag);
-        // When filtering by min_rating client-side, request more results
-        const apiLimit = min_rating ? requestedLimit * 3 : requestedLimit;
+        // min_rating is filtered client-side on avgRating. Request extra candidates
+        // so the post-filter result still has a chance of meeting requestedLimit.
+        const apiLimit = min_rating ? Math.min(100, requestedLimit * 3) : requestedLimit;
         params.set("limit", String(apiLimit));
         if (max_price)
             params.set("price_max", String(max_price));
@@ -45,13 +46,13 @@ export function registerSearchTools(server) {
             params.set("accepted_payment_methods", acceptedMethods.join(","));
         }
         let agents = await apiGet(`/agents?${params}`);
-        // Client-side min_rating filter
+        // Client-side min_rating filter — avgRating is the 1-5 user-facing score.
+        // Agents with no ratings yet (avgRating == null) are excluded when a
+        // minimum is requested, matching user expectation of "at least N stars".
         if (min_rating) {
             agents = agents.filter((a) => {
-                const rating = a.reputationScore ?? a.avgRating ?? 0;
-                // Convert 0-1 reputation to 1-5 scale if needed
-                const stars = rating <= 1 ? rating * 5 : rating;
-                return stars >= min_rating;
+                const avg = a.avgRating ?? a.stats?.avgRating;
+                return typeof avg === "number" && avg >= min_rating;
             });
         }
         // Trim to requested limit after filtering