@agentwonderland/mcp 0.1.25 → 0.1.26

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,7 @@
  */
 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";
@@ -56,13 +56,28 @@ 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, {
@@ -76,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/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/index.js

@@ -40,11 +40,12 @@ 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.",
-            "- 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.",

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

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

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

@@ -0,0 +1,71 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+const mockApiGet = vi.fn();
+const mockIsAuthenticated = vi.fn();
+const mockHasWalletConfigured = vi.fn();
+const mockGetWalletAddress = vi.fn();
+const mockFormatRunResult = vi.fn();
+vi.mock("../../core/api-client.js", () => ({
+    apiGet: mockApiGet,
+}));
+vi.mock("../../core/config.js", () => ({
+    isAuthenticated: mockIsAuthenticated,
+}));
+vi.mock("../../core/payments.js", () => ({
+    hasWalletConfigured: mockHasWalletConfigured,
+    getWalletAddress: mockGetWalletAddress,
+}));
+vi.mock("../../core/formatters.js", () => ({
+    formatRunResult: mockFormatRunResult,
+}));
+function flattenToolText(result) {
+    const content = result?.content ?? [];
+    return content
+        .filter((item) => item?.type === "text")
+        .map((item) => item.text ?? "")
+        .join("\n\n");
+}
+function makeServerHarness() {
+    const handlers = new Map();
+    return {
+        handlers,
+        server: {
+            tool(name, _description, _schema, handler) {
+                handlers.set(name, handler);
+            },
+        },
+    };
+}
+describe("job MCP tools", () => {
+    beforeEach(() => {
+        vi.resetModules();
+        vi.clearAllMocks();
+        mockIsAuthenticated.mockReturnValue(false);
+        mockHasWalletConfigured.mockReturnValue(true);
+        mockGetWalletAddress.mockResolvedValue("0xabc123");
+        mockFormatRunResult.mockReturnValue("formatted job result");
+    });
+    it("appends the wallet address when looking up a job for an unauthenticated consumer", async () => {
+        mockApiGet.mockResolvedValueOnce({ status: "completed", job_id: "job-123" });
+        const { registerJobTools } = await import("../jobs.js");
+        const harness = makeServerHarness();
+        registerJobTools(harness.server);
+        const getJob = harness.handlers.get("get_job");
+        expect(getJob).toBeDefined();
+        const result = await getJob({ job_id: "job-123" });
+        const text = flattenToolText(result);
+        expect(mockApiGet).toHaveBeenCalledWith("/jobs/job-123?wallet=0xabc123");
+        expect(text).toContain("formatted job result");
+    });
+    it("returns a processing message while the async job is still running", async () => {
+        mockApiGet.mockResolvedValueOnce({ status: "processing" });
+        const { registerJobTools } = await import("../jobs.js");
+        const harness = makeServerHarness();
+        registerJobTools(harness.server);
+        const getJob = harness.handlers.get("get_job");
+        expect(getJob).toBeDefined();
+        const result = await getJob({ job_id: "job-456" });
+        const text = flattenToolText(result);
+        expect(mockApiGet).toHaveBeenCalledWith("/jobs/job-456?wallet=0xabc123");
+        expect(text).toContain("Job job-456 is still processing");
+    });
+});

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

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

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

@@ -0,0 +1,149 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+const mockApiGet = vi.fn();
+const mockApiPost = vi.fn();
+const mockApiPostWithPayment = vi.fn();
+const mockGetCompatiblePaymentMethods = vi.fn();
+const mockHasWalletConfigured = vi.fn();
+const mockGetConfiguredMethods = vi.fn();
+const mockGetWalletAddress = vi.fn();
+const mockNormalizePaymentMethod = vi.fn();
+const mockRequiresSpendConfirmation = vi.fn();
+const mockGetDefaultTipAmount = vi.fn();
+const mockCanSpend = vi.fn();
+const mockRecordSpend = vi.fn();
+const mockRequiresPolicyConfirmation = vi.fn();
+const mockUploadLocalFiles = vi.fn();
+const mockStoreFeedbackToken = vi.fn();
+const mockGetActiveCreditPack = vi.fn();
+const mockGetCreditPackInventory = vi.fn();
+const mockGetCreditPackProgram = vi.fn();
+const mockGetOrCreatePendingCardSetup = vi.fn();
+const mockFormatCardSetupBlocks = vi.fn();
+vi.mock("../../core/api-client.js", () => ({
+    apiGet: mockApiGet,
+    apiPost: mockApiPost,
+    apiPostWithPayment: mockApiPostWithPayment,
+}));
+vi.mock("../../core/card-setup.js", () => ({
+    getOrCreatePendingCardSetup: mockGetOrCreatePendingCardSetup,
+    formatCardSetupBlocks: mockFormatCardSetupBlocks,
+}));
+vi.mock("../../core/payments.js", () => ({
+    getCompatiblePaymentMethods: mockGetCompatiblePaymentMethods,
+    getConfiguredMethods: mockGetConfiguredMethods,
+    hasWalletConfigured: mockHasWalletConfigured,
+    getWalletAddress: mockGetWalletAddress,
+    normalizePaymentMethod: mockNormalizePaymentMethod,
+}));
+vi.mock("../../core/config.js", () => ({
+    requiresSpendConfirmation: mockRequiresSpendConfirmation,
+    getDefaultTipAmount: mockGetDefaultTipAmount,
+}));
+vi.mock("../../core/spend-policy.js", () => ({
+    canSpend: mockCanSpend,
+    recordSpend: mockRecordSpend,
+    requiresPolicyConfirmation: mockRequiresPolicyConfirmation,
+}));
+vi.mock("../../core/file-upload.js", () => ({
+    uploadLocalFiles: mockUploadLocalFiles,
+}));
+vi.mock("../_token-cache.js", () => ({
+    storeFeedbackToken: mockStoreFeedbackToken,
+}));
+vi.mock("../../core/passes.js", () => ({
+    formatCreditPackOffer: vi.fn(),
+    getActiveCreditPack: mockGetActiveCreditPack,
+    getCreditPackInventory: mockGetCreditPackInventory,
+    getCreditPackProgram: mockGetCreditPackProgram,
+}));
+function flattenToolText(result) {
+    const content = result?.content ?? [];
+    return content
+        .filter((item) => item?.type === "text")
+        .map((item) => item.text ?? "")
+        .join("\n\n");
+}
+function makeServerHarness() {
+    const handlers = new Map();
+    return {
+        handlers,
+        server: {
+            tool(name, _description, _schema, handler) {
+                handlers.set(name, handler);
+            },
+        },
+    };
+}
+const selectedAgent = {
+    id: "agent-1",
+    name: "MockFixedPrice",
+    pricePerRunUsd: "0.01",
+    tags: ["translation"],
+    mcpSchema: null,
+};
+describe("run_agent MCP tool", () => {
+    beforeEach(() => {
+        vi.resetModules();
+        vi.clearAllMocks();
+        mockHasWalletConfigured.mockReturnValue(true);
+        mockGetConfiguredMethods.mockReturnValue(["card"]);
+        mockGetCompatiblePaymentMethods.mockReturnValue(["card"]);
+        mockNormalizePaymentMethod.mockImplementation((method) => method);
+        mockRequiresSpendConfirmation.mockReturnValue(true);
+        mockGetDefaultTipAmount.mockReturnValue(0);
+        mockCanSpend.mockReturnValue({ ok: true, message: "" });
+        mockRequiresPolicyConfirmation.mockReturnValue(false);
+        mockUploadLocalFiles.mockResolvedValue({ input: { text: "hello", target_language: "es" }, uploads: [] });
+        mockGetActiveCreditPack.mockReturnValue(null);
+        mockGetCreditPackInventory.mockResolvedValue([]);
+        mockGetCreditPackProgram.mockReturnValue(null);
+        mockGetOrCreatePendingCardSetup.mockResolvedValue({ url: "https://example.com/card-setup" });
+        mockFormatCardSetupBlocks.mockReturnValue(["card setup"]);
+        mockGetWalletAddress.mockResolvedValue("0xabc");
+        mockApiGet.mockResolvedValue(selectedAgent);
+    });
+    it("quotes explicit agent execution before running", async () => {
+        const { registerRunTools } = await import("../run.js");
+        const harness = makeServerHarness();
+        registerRunTools(harness.server);
+        const runAgent = harness.handlers.get("run_agent");
+        expect(runAgent).toBeDefined();
+        const result = await runAgent({
+            agent_id: selectedAgent.id,
+            input: { text: "hello", target_language: "es" },
+            pay_with: "card",
+        });
+        const text = flattenToolText(result);
+        expect(text).toContain("Ready to run MockFixedPrice");
+        expect(text).toContain('run_agent({ agent_id: "agent-1", input: <same>, pay_with: "card", confirmed: true })');
+        expect(mockApiPostWithPayment).not.toHaveBeenCalled();
+    });
+    it("runs the explicitly selected agent when confirmed", async () => {
+        mockApiPostWithPayment.mockResolvedValueOnce({
+            status: "success",
+            job_id: "job-1",
+            agent_id: selectedAgent.id,
+            agent_name: selectedAgent.name,
+            output: { translated_text: "hola" },
+            cost: 0.01,
+        });
+        const { registerRunTools } = await import("../run.js");
+        const harness = makeServerHarness();
+        registerRunTools(harness.server);
+        const runAgent = harness.handlers.get("run_agent");
+        expect(runAgent).toBeDefined();
+        const result = await runAgent({
+            agent_id: selectedAgent.id,
+            input: { text: "hello", target_language: "es" },
+            pay_with: "card",
+            confirmed: true,
+        });
+        const text = flattenToolText(result);
+        expect(mockApiPostWithPayment).toHaveBeenCalledWith("/agents/agent-1/run", { input: { text: "hello", target_language: "es" } }, "card");
+        expect(mockRecordSpend).toHaveBeenCalledWith("card", 0.01);
+        expect(text).toContain("translated_text");
+        expect(text).toContain("✓ MockFixedPrice");
+        expect(text).toContain("Paid: $0.01 via card");
+        expect(text).toContain("Job ID: job-1");
+    });
+});

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

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

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

@@ -0,0 +1,158 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+const mockApiGet = vi.fn();
+const mockApiPost = vi.fn();
+const mockApiPostWithPayment = vi.fn();
+const mockGetCompatiblePaymentMethods = vi.fn();
+const mockHasWalletConfigured = vi.fn();
+const mockGetConfiguredMethods = vi.fn();
+const mockGetAcceptedPaymentMethods = vi.fn();
+const mockGetWalletAddress = vi.fn();
+const mockNormalizePaymentMethod = vi.fn();
+const mockToRegistryPaymentMethod = vi.fn();
+const mockRequiresSpendConfirmation = vi.fn();
+const mockGetDefaultTipAmount = vi.fn();
+const mockCanSpend = vi.fn();
+const mockRecordSpend = vi.fn();
+const mockRequiresPolicyConfirmation = vi.fn();
+const mockUploadLocalFiles = vi.fn();
+const mockStoreFeedbackToken = vi.fn();
+const mockGetActiveCreditPack = vi.fn();
+const mockGetCreditPackInventory = vi.fn();
+const mockGetCreditPackProgram = vi.fn();
+const mockGetOrCreatePendingCardSetup = vi.fn();
+const mockFormatCardSetupBlocks = vi.fn();
+vi.mock("../../core/api-client.js", () => ({
+    apiGet: mockApiGet,
+    apiPost: mockApiPost,
+    apiPostWithPayment: mockApiPostWithPayment,
+}));
+vi.mock("../../core/card-setup.js", () => ({
+    getOrCreatePendingCardSetup: mockGetOrCreatePendingCardSetup,
+    formatCardSetupBlocks: mockFormatCardSetupBlocks,
+}));
+vi.mock("../../core/payments.js", () => ({
+    getCompatiblePaymentMethods: mockGetCompatiblePaymentMethods,
+    hasWalletConfigured: mockHasWalletConfigured,
+    getConfiguredMethods: mockGetConfiguredMethods,
+    getAcceptedPaymentMethods: mockGetAcceptedPaymentMethods,
+    getWalletAddress: mockGetWalletAddress,
+    normalizePaymentMethod: mockNormalizePaymentMethod,
+    toRegistryPaymentMethod: mockToRegistryPaymentMethod,
+}));
+vi.mock("../../core/config.js", () => ({
+    requiresSpendConfirmation: mockRequiresSpendConfirmation,
+    getDefaultTipAmount: mockGetDefaultTipAmount,
+}));
+vi.mock("../../core/spend-policy.js", () => ({
+    canSpend: mockCanSpend,
+    recordSpend: mockRecordSpend,
+    requiresPolicyConfirmation: mockRequiresPolicyConfirmation,
+}));
+vi.mock("../../core/file-upload.js", () => ({
+    uploadLocalFiles: mockUploadLocalFiles,
+}));
+vi.mock("../_token-cache.js", () => ({
+    storeFeedbackToken: mockStoreFeedbackToken,
+}));
+vi.mock("../../core/passes.js", () => ({
+    getActiveCreditPack: mockGetActiveCreditPack,
+    getCreditPackInventory: mockGetCreditPackInventory,
+    getCreditPackProgram: mockGetCreditPackProgram,
+}));
+function flattenToolText(result) {
+    const content = result?.content ?? [];
+    return content
+        .filter((item) => item?.type === "text")
+        .map((item) => item.text ?? "")
+        .join("\n\n");
+}
+function makeServerHarness() {
+    const handlers = new Map();
+    return {
+        handlers,
+        server: {
+            tool(name, _description, _schema, handler) {
+                handlers.set(name, handler);
+            },
+        },
+    };
+}
+const selectedAgent = {
+    id: "agent-1",
+    name: "MockFixedPrice",
+    pricePerRunUsd: "0.01",
+    tags: ["translation"],
+    mcpSchema: null,
+};
+describe("solve MCP tool", () => {
+    beforeEach(() => {
+        vi.resetModules();
+        vi.clearAllMocks();
+        mockHasWalletConfigured.mockReturnValue(true);
+        mockGetConfiguredMethods.mockReturnValue(["card"]);
+        mockGetAcceptedPaymentMethods.mockReturnValue(["card"]);
+        mockGetCompatiblePaymentMethods.mockReturnValue(["card"]);
+        mockNormalizePaymentMethod.mockImplementation((method) => method);
+        mockToRegistryPaymentMethod.mockImplementation((method) => method);
+        mockRequiresSpendConfirmation.mockReturnValue(true);
+        mockGetDefaultTipAmount.mockReturnValue(0);
+        mockCanSpend.mockReturnValue({ ok: true, message: "" });
+        mockRequiresPolicyConfirmation.mockReturnValue(false);
+        mockUploadLocalFiles.mockResolvedValue({ input: { text: "hello", target_language: "es" }, uploads: [] });
+        mockGetActiveCreditPack.mockReturnValue(null);
+        mockGetCreditPackInventory.mockResolvedValue([]);
+        mockGetCreditPackProgram.mockReturnValue(null);
+        mockGetOrCreatePendingCardSetup.mockResolvedValue({ url: "https://example.com/card-setup" });
+        mockFormatCardSetupBlocks.mockReturnValue(["card setup"]);
+        mockGetWalletAddress.mockResolvedValue("0xabc");
+    });
+    it("falls back to a quoted confirmation flow when /solve returns a 402 challenge", async () => {
+        mockApiPost.mockRejectedValueOnce(Object.assign(new Error("Payment Required"), { status: 402 }));
+        mockApiGet.mockResolvedValueOnce([selectedAgent]);
+        const { registerSolveTools } = await import("../solve.js");
+        const harness = makeServerHarness();
+        registerSolveTools(harness.server);
+        const solve = harness.handlers.get("solve");
+        expect(solve).toBeDefined();
+        const result = await solve({
+            intent: "MockFixedPrice",
+            input: { text: "hello", target_language: "es" },
+            budget: 0.05,
+            pay_with: "card",
+        });
+        const text = flattenToolText(result);
+        expect(text).toContain("Best match: MockFixedPrice");
+        expect(text).toContain('solve({ intent: "MockFixedPrice"');
+        expect(text).toContain('pay_with: "card"');
+        expect(mockApiPostWithPayment).not.toHaveBeenCalled();
+    });
+    it("falls back to paid execution when confirmed after a 402 challenge", async () => {
+        mockApiPost.mockRejectedValueOnce(Object.assign(new Error("Payment Required"), { status: 402 }));
+        mockApiGet.mockResolvedValueOnce([selectedAgent]);
+        mockApiPostWithPayment.mockResolvedValueOnce({
+            status: "success",
+            job_id: "job-1",
+            agent_id: selectedAgent.id,
+            agent_name: selectedAgent.name,
+            output: { translated_text: "hola" },
+            cost: 0.01,
+        });
+        const { registerSolveTools } = await import("../solve.js");
+        const harness = makeServerHarness();
+        registerSolveTools(harness.server);
+        const solve = harness.handlers.get("solve");
+        expect(solve).toBeDefined();
+        const result = await solve({
+            intent: "MockFixedPrice",
+            input: { text: "hello", target_language: "es" },
+            budget: 0.05,
+            pay_with: "card",
+            confirmed: true,
+        });
+        const text = flattenToolText(result);
+        expect(mockApiPostWithPayment).toHaveBeenCalledWith("/agents/agent-1/run", { input: { text: "hello", target_language: "es" } }, "card");
+        expect(text).toContain("Running MockFixedPrice — best match");
+        expect(text).toContain("Job ID: job-1");
+        expect(text).toContain("Paid: $0.01 via card");
+    });
+});

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

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