@agentwonderland/mcp 0.1.23 → 0.1.24

package/dist/core/__tests__/card-setup.test.d.ts

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

package/dist/core/__tests__/card-setup.test.js

@@ -0,0 +1,99 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+const mockApiGet = vi.fn();
+const mockApiPost = vi.fn();
+class MockApiError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = "ApiError";
+    }
+}
+let pendingToken = null;
+const savedCards = [];
+vi.mock("../api-client.js", () => ({
+    ApiError: MockApiError,
+    apiGet: (...args) => mockApiGet(...args),
+    apiPost: (...args) => mockApiPost(...args),
+}));
+vi.mock("../config.js", () => ({
+    getApiUrl: () => "http://api.test",
+    getPendingCardSetupToken: () => pendingToken,
+    setCardConfig: (card) => {
+        savedCards.push(card);
+    },
+    setPendingCardSetupToken: (token) => {
+        pendingToken = token;
+    },
+}));
+describe("card setup helpers", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        pendingToken = null;
+        savedCards.length = 0;
+    });
+    it("reuses the existing pending setup token", async () => {
+        pendingToken = "tok_existing";
+        const { getOrCreatePendingCardSetup } = await import("../card-setup.js");
+        const result = await getOrCreatePendingCardSetup();
+        expect(mockApiPost).not.toHaveBeenCalled();
+        expect(result).toMatchObject({
+            token: "tok_existing",
+            url: "http://api.test/card/handoff/tok_existing",
+            isNew: false,
+        });
+    });
+    it("stores a newly created setup token for later resume", async () => {
+        mockApiPost.mockResolvedValueOnce({ token: "tok_new" });
+        const { getOrCreatePendingCardSetup } = await import("../card-setup.js");
+        const result = await getOrCreatePendingCardSetup();
+        expect(mockApiPost).toHaveBeenCalledWith("/card/setup", {});
+        expect(pendingToken).toBe("tok_new");
+        expect(result).toMatchObject({
+            token: "tok_new",
+            url: "http://api.test/card/handoff/tok_new",
+            isNew: true,
+        });
+    });
+    it("persists the card and clears pending setup on successful completion", async () => {
+        pendingToken = "tok_ready";
+        mockApiGet.mockResolvedValueOnce({
+            status: "complete",
+            card_last4: "4242",
+            card_brand: "visa",
+            consumer_token: "consumer_123",
+            payment_method_id: "pm_123",
+        });
+        const { pollCardSetup } = await import("../card-setup.js");
+        const result = await pollCardSetup("tok_ready", 50);
+        expect(result).toEqual({
+            last4: "4242",
+            brand: "visa",
+            consumerToken: "consumer_123",
+        });
+        expect(savedCards).toEqual([{
+                consumerToken: "consumer_123",
+                paymentMethodId: "pm_123",
+                last4: "4242",
+                brand: "visa",
+            }]);
+        expect(pendingToken).toBeNull();
+    });
+    it("clears expired pending setup tokens", async () => {
+        pendingToken = "tok_expired";
+        mockApiGet.mockRejectedValueOnce(new MockApiError(404, "Setup not found"));
+        const { pollCardSetup } = await import("../card-setup.js");
+        const result = await pollCardSetup("tok_expired", 50);
+        expect(result).toBeNull();
+        expect(pendingToken).toBeNull();
+    });
+    it("formats card setup as a single visible message with the setup page URL", async () => {
+        const { formatCardSetupBlocks } = await import("../card-setup.js");
+        const blocks = formatCardSetupBlocks("http://api.test/card/handoff/tok");
+        expect(blocks).toHaveLength(1);
+        expect(blocks[0]).toContain("Open this setup page to connect your card:");
+        expect(blocks[0]).toContain("http://api.test/card/handoff/tok");
+        expect(blocks[0]).toContain("securely save the card");
+        expect(blocks[0]).not.toContain("QR code above");
+    });
+});

package/dist/core/__tests__/formatters.test.d.ts

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

package/dist/core/__tests__/formatters.test.js

@@ -0,0 +1,15 @@
+import { describe, expect, it } from "vitest";
+import { formatRunResult } from "../formatters.js";
+describe("formatRunResult", () => {
+    it("does not show a paid line for credit-pack-backed runs with zero cost", () => {
+        const output = formatRunResult({
+            agent_name: "Credit Pack Agent",
+            status: "success",
+            cost: 0,
+            consumption_mode: "credit_pack",
+            credit_pack_id: "pack-123",
+        }, { paymentMethod: "card" });
+        expect(output).toContain("Covered by credit pack (pack-123)");
+        expect(output).not.toContain("Paid:");
+    });
+});

package/dist/core/__tests__/passes.test.d.ts

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

package/dist/core/__tests__/passes.test.js

@@ -0,0 +1,82 @@
+import { describe, expect, it } from "vitest";
+import { formatCreditPack, formatCreditPackOffer, getActiveCreditPack, getCreditPackProgram, } from "../passes.js";
+const baseAgent = {
+    id: "agent-1",
+    name: "Test Agent",
+    payment: {
+        credit_packs: {
+            unit_type: "run",
+            packs: [
+                { key: "starter", name: "Starter Pack", included_units: 5, price_usd: "1.00" },
+                { key: "growth", name: "Growth Pack", included_units: 20, price_usd: "3.00" },
+            ],
+        },
+    },
+};
+describe("getCreditPackProgram", () => {
+    it("returns the configured credit-pack program from agent metadata", () => {
+        expect(getCreditPackProgram(baseAgent)).toEqual({
+            unit_type: "run",
+            packs: [
+                { key: "starter", name: "Starter Pack", included_units: 5, price_usd: "1.00" },
+                { key: "growth", name: "Growth Pack", included_units: 20, price_usd: "3.00" },
+            ],
+        });
+    });
+});
+describe("formatCreditPackOffer", () => {
+    it("shows units and per-unit price", () => {
+        expect(formatCreditPackOffer({
+            pack_id: "starter",
+            label: "Starter Pack",
+            included_units: 5,
+            price_usd: "1.00",
+            effective_price_per_unit_usd: "0.200000",
+        })).toContain("Starter Pack");
+    });
+});
+describe("formatCreditPack", () => {
+    it("includes the pack status when it is no longer active", () => {
+        expect(formatCreditPack({
+            id: "pack-1",
+            status: "depleted",
+            unit_type: "run",
+            included_units: 5,
+            remaining_units: 0,
+            price_usd: "1.00",
+            purchased_at: "2026-05-04T15:08:28.700Z",
+            pack: { key: "starter", name: "Starter Pack" },
+        })).toContain("depleted");
+    });
+});
+describe("getActiveCreditPack", () => {
+    it("returns the oldest active balance with remaining units", () => {
+        const pack = getActiveCreditPack({
+            consumer_principal: "did:pkh:eip155:8453:0x1111111111111111111111111111111111111111",
+            offers: [],
+            balances: [
+                {
+                    id: "newer",
+                    status: "active",
+                    unit_type: "run",
+                    included_units: 20,
+                    remaining_units: 20,
+                    price_usd: "3.00",
+                    purchased_at: "2026-04-10T00:00:00Z",
+                    pack: { key: "growth", name: "Growth Pack" },
+                },
+                {
+                    id: "older",
+                    status: "active",
+                    unit_type: "run",
+                    included_units: 5,
+                    remaining_units: 2,
+                    price_usd: "1.00",
+                    purchased_at: "2026-04-01T00:00:00Z",
+                    pack: { key: "starter", name: "Starter Pack" },
+                },
+            ],
+        });
+        expect(pack?.id).toBe("older");
+    });
+});

package/dist/core/__tests__/payments.test.d.ts

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

package/dist/core/__tests__/payments.test.js

@@ -0,0 +1,52 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+let currentCard = {
+    consumerToken: "consumer_one",
+    paymentMethodId: "pm_one",
+    last4: "1111",
+    brand: "visa",
+};
+const createdFetches = [vi.fn(), vi.fn(), vi.fn()];
+const mockMppxCreate = vi.fn();
+const mockStripe = vi.fn((opts) => opts);
+vi.mock("../config.js", () => ({
+    getApiUrl: () => "http://api.test",
+    getCardConfig: () => currentCard,
+    getConfig: () => ({ defaultPaymentMethod: "card" }),
+    getDefaultWallet: () => undefined,
+    getWallets: () => [],
+    resolveWalletAndChain: () => null,
+}));
+vi.mock("mppx/client", () => ({
+    Mppx: {
+        create: (config) => mockMppxCreate(config),
+    },
+    stripe: (config) => mockStripe(config),
+}));
+describe("card payment fetch cache", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        currentCard = {
+            consumerToken: "consumer_one",
+            paymentMethodId: "pm_one",
+            last4: "1111",
+            brand: "visa",
+        };
+        mockMppxCreate
+            .mockReturnValueOnce({ fetch: createdFetches[0] })
+            .mockReturnValueOnce({ fetch: createdFetches[1] })
+            .mockReturnValueOnce({ fetch: createdFetches[2] });
+    });
+    it("rebuilds the cached card fetch when the card config changes", async () => {
+        const { getPaymentFetch } = await import("../payments.js");
+        const firstFetch = await getPaymentFetch("card");
+        currentCard = {
+            consumerToken: "consumer_two",
+            paymentMethodId: "pm_two",
+            last4: "2222",
+            brand: "mastercard",
+        };
+        const secondFetch = await getPaymentFetch("card");
+        expect(firstFetch).not.toBe(secondFetch);
+        expect(mockMppxCreate).toHaveBeenCalledTimes(2);
+    });
+});

package/dist/core/__tests__/principal.test.d.ts

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

package/dist/core/__tests__/principal.test.js

@@ -0,0 +1,67 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+const state = vi.hoisted(() => ({
+    wallets: [],
+    addresses: {},
+    addedWallets: [],
+    owsAvailable: false,
+    owsWallets: [],
+}));
+vi.mock("../config.js", () => ({
+    addWallet: (wallet) => {
+        state.addedWallets.push(wallet);
+        state.wallets.push(wallet);
+    },
+    getDefaultWallet: () => state.wallets[0],
+    getWallets: () => state.wallets,
+}));
+vi.mock("../payments.js", () => ({
+    getWalletAddress: async (walletId) => {
+        if (walletId in state.addresses) {
+            return state.addresses[walletId] ?? null;
+        }
+        const wallet = state.wallets.find((entry) => entry.id === walletId);
+        if (wallet?.key) {
+            const { privateKeyToAccount } = await import("viem/accounts");
+            return privateKeyToAccount(wallet.key).address;
+        }
+        return null;
+    },
+}));
+vi.mock("../ows-adapter.js", () => ({
+    createOwsWallet: async (name) => ({
+        walletId: `ows-${name}`,
+        address: "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+    }),
+    isOwsAvailable: async () => state.owsAvailable,
+    listOwsWallets: async () => state.owsWallets,
+}));
+describe("consumer principal helpers", () => {
+    beforeEach(() => {
+        vi.resetModules();
+        state.wallets = [];
+        state.addresses = {};
+        state.addedWallets = [];
+        state.owsAvailable = false;
+        state.owsWallets = [];
+    });
+    it("prefers an EVM-backed principal when both EVM and Solana wallets exist", async () => {
+        state.wallets = [
+            { id: "sol-wallet", keyType: "ows", owsWalletId: "ows-sol", chains: ["solana"], defaultChain: "solana" },
+            { id: "evm-wallet", keyType: "evm", key: "0x1234", chains: ["tempo", "base"], defaultChain: "base" },
+        ];
+        state.addresses = {
+            "sol-wallet": "So1ana11111111111111111111111111111111111111",
+            "evm-wallet": "0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
+        };
+        const { getConsumerPrincipal } = await import("../principal.js");
+        const principal = await getConsumerPrincipal();
+        expect(principal).toBe("did:pkh:eip155:8453:0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
+    });
+    it("creates a fallback EVM identity wallet when none exists", async () => {
+        const { ensureConsumerPrincipal } = await import("../principal.js");
+        const principal = await ensureConsumerPrincipal();
+        expect(principal).toMatch(/^did:pkh:eip155:8453:0x[a-f0-9]{40}$/);
+        expect(state.addedWallets).toHaveLength(1);
+        expect(state.addedWallets[0]?.chains).toEqual(["tempo", "base"]);
+    });
+});

package/dist/core/api-client.d.ts

@@ -3,12 +3,17 @@ export declare class ApiError extends Error {
     readonly body?: unknown | undefined;
     constructor(status: number, message: string, body?: unknown | undefined);
 }
-export declare function apiGet<T>(path: string): Promise<T>;
-export declare function apiPost<T>(path: string, body: unknown): Promise<T>;
+interface RequestOptions {
+    ensureConsumerPrincipal?: boolean;
+    extraHeaders?: Record<string, string>;
+}
+export declare function apiGet<T>(path: string, options?: RequestOptions): Promise<T>;
+export declare function apiPost<T>(path: string, body: unknown, options?: RequestOptions): Promise<T>;
 /**
  * POST with payment support. Uses the configured payment method to
  * auto-handle 402 → sign → retry for paid endpoints.
  * Pass `payWith` to specify a method, or omit for auto-detection.
  */
-export declare function apiPostWithPayment<T>(path: string, body: unknown, payWith?: string): Promise<T>;
-export declare function apiPut<T>(path: string, body: unknown): Promise<T>;
+export declare function apiPostWithPayment<T>(path: string, body: unknown, payWith?: string, options?: RequestOptions): Promise<T>;
+export declare function apiPut<T>(path: string, body: unknown, options?: RequestOptions): Promise<T>;
+export {};

package/dist/core/api-client.js

@@ -1,5 +1,6 @@
 import { getApiUrl, getApiKey } from "./config.js";
 import { getPaymentFetch } from "./payments.js";
+import { ensureConsumerPrincipal, getConsumerPrincipal } from "./principal.js";
 // ── Error class ────────────────────────────────────────────────────
 export class ApiError extends Error {
     status;
@@ -11,8 +12,7 @@ export class ApiError extends Error {
         this.name = "ApiError";
     }
 }
-// ── Internal helpers ───────────────────────────────────────────────
-function buildHeaders() {
+async function buildHeaders(options) {
     const headers = {
         "Content-Type": "application/json",
         Accept: "application/json",
@@ -21,6 +21,15 @@ function buildHeaders() {
     if (apiKey) {
         headers["Authorization"] = `Bearer ${apiKey}`;
     }
+    const principal = options?.ensureConsumerPrincipal
+        ? await ensureConsumerPrincipal()
+        : await getConsumerPrincipal();
+    if (principal) {
+        headers["X-AW-Consumer-Principal"] = principal;
+    }
+    if (options?.extraHeaders) {
+        Object.assign(headers, options.extraHeaders);
+    }
     return headers;
 }
 async function handleResponse(response) {
@@ -45,54 +54,75 @@ async function handleResponse(response) {
     }
     return body;
 }
+function attachResponseMetadata(result, response) {
+    if (!result || typeof result !== "object") {
+        return result;
+    }
+    const record = result;
+    const headerToken = response.headers.get("x-feedback-token");
+    if (headerToken && !("feedback_token" in record)) {
+        record.feedback_token = headerToken;
+    }
+    const consumptionMode = response.headers.get("x-aw-consumption-mode");
+    if (consumptionMode) {
+        record.consumption_mode = consumptionMode;
+    }
+    const creditPackId = response.headers.get("x-aw-credit-pack-id");
+    if (creditPackId) {
+        record.credit_pack_id = creditPackId;
+    }
+    const principal = response.headers.get("x-aw-consumer-principal");
+    if (principal) {
+        record.consumer_principal = principal;
+    }
+    return result;
+}
 // ── Public API ─────────────────────────────────────────────────────
-export async function apiGet(path) {
+export async function apiGet(path, options) {
     const url = `${getApiUrl()}${path}`;
     const response = await fetch(url, {
         method: "GET",
-        headers: buildHeaders(),
+        headers: await buildHeaders(options),
     });
-    return handleResponse(response);
+    const result = await handleResponse(response);
+    return attachResponseMetadata(result, response);
 }
-export async function apiPost(path, body) {
+export async function apiPost(path, body, options) {
     const url = `${getApiUrl()}${path}`;
     const response = await fetch(url, {
         method: "POST",
-        headers: buildHeaders(),
+        headers: await buildHeaders(options),
         body: JSON.stringify(body),
     });
-    return handleResponse(response);
+    const result = await handleResponse(response);
+    return attachResponseMetadata(result, response);
 }
 /**
  * POST with payment support. Uses the configured payment method to
  * auto-handle 402 → sign → retry for paid endpoints.
  * Pass `payWith` to specify a method, or omit for auto-detection.
  */
-export async function apiPostWithPayment(path, body, payWith) {
+export async function apiPostWithPayment(path, body, payWith, options) {
     const url = `${getApiUrl()}${path}`;
     const paymentFetch = await getPaymentFetch(payWith);
     const response = await paymentFetch(url, {
         method: "POST",
-        headers: buildHeaders(),
+        headers: await buildHeaders({
+            ensureConsumerPrincipal: true,
+            ...options,
+        }),
         body: JSON.stringify(body),
     });
     const result = await handleResponse(response);
-    // mppx may strip extra fields from the response body during receipt processing.
-    // The gateway also sends feedback_token as a header to survive this.
-    if (result && typeof result === "object" && !("feedback_token" in result)) {
-        const headerToken = response.headers.get("x-feedback-token");
-        if (headerToken) {
-            result.feedback_token = headerToken;
-        }
-    }
-    return result;
+    return attachResponseMetadata(result, response);
 }
-export async function apiPut(path, body) {
+export async function apiPut(path, body, options) {
     const url = `${getApiUrl()}${path}`;
     const response = await fetch(url, {
         method: "PUT",
-        headers: buildHeaders(),
+        headers: await buildHeaders(options),
         body: JSON.stringify(body),
     });
-    return handleResponse(response);
+    const result = await handleResponse(response);
+    return attachResponseMetadata(result, response);
 }

package/dist/core/card-setup.d.ts

@@ -1,23 +1,30 @@
+export interface CardSetupResult {
+    last4: string;
+    brand: string;
+    consumerToken: string;
+}
+export interface CardCapabilities {
+    spt_status: "enabled" | "unavailable" | "unknown";
+    message?: string;
+}
 /**
- * Initiate card setup — creates a Stripe Checkout session and returns
- * QR code + short URL for the user to scan.
+ * Create a new card setup session or resume the pending one from config.
  */
-export declare function initiateCardSetup(): Promise<{
-    qr: string;
+export declare function getOrCreatePendingCardSetup(): Promise<{
     url: string;
     token: string;
+    isNew: boolean;
 }>;
 /**
- * Format the card setup prompt as multiple content blocks.
- * Block 1: QR code (may be collapsed in some clients)
- * Block 2: URL + instructions (short, always visible)
+ * Format the card setup prompt as a single text block.
+ *
+ * Some MCP clients only surface one text chunk or collapse multi-part tool
+ * output, which can hide the QR code entirely. Keeping everything in one
+ * message makes the browser handoff much more reliable.
  */
-export declare function formatCardSetupBlocks(qr: string, url: string): string[];
+export declare function formatCardSetupBlocks(url: string): string[];
 /**
  * Poll for card setup completion. Returns the card details or null on timeout.
  */
-export declare function pollCardSetup(token: string, timeoutMs?: number): Promise<{
-    last4: string;
-    brand: string;
-    consumerToken: string;
-} | null>;
+export declare function pollCardSetup(token: string, timeoutMs?: number): Promise<CardSetupResult | null>;
+export declare function getCardCapabilities(): Promise<CardCapabilities>;