@agentwonderland/mcp 0.1.24 → 0.1.26

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 {};

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

@@ -20,7 +20,7 @@ export function registerAgentInfoTools(server) {
             "",
             a.description ?? "",
             "",
-            `Pricing: ${formatPrice(a.pricePer1kTokens, a.pricingModel)}`,
+            `Pricing: ${formatPrice(a.pricePerRunUsd)}`,
             `Reliability: ${a.successRate != null ? (Number(a.successRate) * 100).toFixed(0) + "%" : "N/A"}`,
             `Avg latency: ${a.avgResponseTimeMs != null ? a.avgResponseTimeMs + "ms" : "N/A"}`,
             ...(() => {
@@ -100,7 +100,7 @@ export function registerAgentInfoTools(server) {
             return [
                 `  ${a.name}`,
                 `  ${stars(rating)} (${s.ratingCount ?? 0} reviews)${tipCount > 0 ? ` • ${tipCount} tips` : ""}`,
-                `  ${compactNumber(jobs)} jobs • ${formatPrice(a.pricePer1kTokens, a.pricingModel)}`,
+                `  ${compactNumber(jobs)} jobs • ${formatPrice(a.pricePerRunUsd)}`,
                 `  Success: ${a.successRate != null ? (Number(a.successRate) * 100).toFixed(0) + "%" : "N/A"}`,
                 `  ${agentWebUrl(a.id)}`,
                 "",

package/dist/tools/favorites.js

@@ -34,7 +34,7 @@ export function registerFavoriteTools(server) {
                 const agent = await apiGet(`/agents/${id}`);
                 const rating = stars(agent.avgRating);
                 const jobs = compactNumber(agent.totalExecutions);
-                const price = formatPrice(agent.pricePer1kTokens, agent.pricingModel);
+                const price = formatPrice(agent.pricePerRunUsd);
                 lines.push(`${agent.name} ${rating} ${jobs} jobs | ${price}`);
                 lines.push(`  ID: ${id}`);
                 if (agent.description)

package/dist/tools/jobs.js

@@ -11,7 +11,14 @@ export function registerJobTools(server) {
     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}`);
+        let url = `/jobs/${job_id}`;
+        if (!isAuthenticated() && hasWalletConfigured()) {
+            const address = await getWalletAddress();
+            if (address) {
+                url += `?wallet=${encodeURIComponent(address)}`;
+            }
+        }
+        const result = await apiGet(url);
         if (result.status === "processing") {
             return text(`Job ${job_id} is still processing...`);
         }

package/dist/tools/observability.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerObservabilityTools(server: McpServer): void;