@agentwonderland/mcp 0.1.23 → 0.1.24

package/dist/core/card-setup.js

@@ -1,41 +1,50 @@
-import QRCode from "qrcode";
-import { apiPost, apiGet } from "./api-client.js";
-import { getApiUrl, setCardConfig } from "./config.js";
+import { apiPost, apiGet, ApiError } from "./api-client.js";
+import { getApiUrl, setCardConfig, getPendingCardSetupToken, setPendingCardSetupToken, } from "./config.js";
+let cachedCapabilities = null;
+function buildCardSetupUrl(token) {
+    return `${getApiUrl()}/card/handoff/${token}`;
+}
 /**
- * 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 async function initiateCardSetup() {
-    const { url: _checkoutUrl, token } = await apiPost("/card/setup", {});
-    // Short redirect URL keeps the QR code small and scannable
-    const apiUrl = getApiUrl();
-    const shortUrl = `${apiUrl}/card/link/${token}`;
-    const rawQr = await QRCode.toString(shortUrl, {
-        type: "utf8",
-        errorCorrectionLevel: "L",
-        margin: 2,
-    });
-    // Pad every line with consistent leading spaces so the QR aligns
-    // properly in terminal renderers that add prefixes to the first line
-    const qr = rawQr.split("\n").map((line) => "  " + line).join("\n");
-    return { qr, url: shortUrl, token };
+export async function getOrCreatePendingCardSetup() {
+    const pendingToken = getPendingCardSetupToken();
+    if (pendingToken) {
+        const url = buildCardSetupUrl(pendingToken);
+        return {
+            url,
+            token: pendingToken,
+            isNew: false,
+        };
+    }
+    const { token } = await apiPost("/card/setup", {});
+    setPendingCardSetupToken(token);
+    const url = buildCardSetupUrl(token);
+    return {
+        url,
+        token,
+        isNew: true,
+    };
 }
 /**
- * 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 function formatCardSetupBlocks(qr, url) {
+export function formatCardSetupBlocks(url) {
     return [
-        "\n" + qr.trim(),
         [
-            `IMPORTANT: You MUST present this link to the user so they can connect a payment card:`,
+            "Open this setup page to connect your card:",
             "",
             url,
             "",
-            `Tell the user: "Scan the QR code above or open this link to connect your card. Let me know when you're done."`,
+            "The setup page will take you to Stripe to securely save the card.",
+            "",
+            `Tell the user: "Open this setup page to connect your card. Let me know when you're done."`,
             `After they confirm, call wallet_setup({ action: "add-card" }) to complete setup.`,
-            `Crypto wallets (Base/Tempo USDC) are also available via wallet_setup({ action: "create" }).`,
+            `Crypto wallets (Tempo, Base, or Solana USDC) are also available via wallet_setup({ action: "create" }).`,
         ].join("\n"),
     ];
 }
@@ -45,7 +54,6 @@ export function formatCardSetupBlocks(qr, url) {
 export async function pollCardSetup(token, timeoutMs = 120_000) {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
-        await new Promise((r) => setTimeout(r, 3000));
         try {
             const status = await apiGet(`/card/status?token=${token}`);
             if (status.status === "complete" && status.consumer_token) {
@@ -61,12 +69,60 @@ export async function pollCardSetup(token, timeoutMs = 120_000) {
                     last4: card.last4,
                     brand: card.brand,
                 });
+                setPendingCardSetupToken(null);
                 return card;
             }
         }
-        catch {
+        catch (err) {
+            if (err instanceof ApiError && err.status === 404) {
+                setPendingCardSetupToken(null);
+                return null;
+            }
             // Keep polling
         }
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0)
+            break;
+        await new Promise((r) => setTimeout(r, Math.min(3000, remainingMs)));
     }
     return null;
 }
+export async function getCardCapabilities() {
+    const apiUrl = getApiUrl();
+    if (cachedCapabilities && cachedCapabilities.apiUrl === apiUrl && cachedCapabilities.expiresAt > Date.now()) {
+        return cachedCapabilities.value;
+    }
+    try {
+        const capabilities = await apiGet("/card/capabilities");
+        cachedCapabilities = {
+            value: capabilities,
+            apiUrl,
+            expiresAt: Date.now() + 30_000,
+        };
+        return capabilities;
+    }
+    catch (err) {
+        if (err instanceof ApiError) {
+            const fallback = {
+                spt_status: "unknown",
+                message: err.message,
+            };
+            cachedCapabilities = {
+                value: fallback,
+                apiUrl,
+                expiresAt: Date.now() + 10_000,
+            };
+            return fallback;
+        }
+        const fallback = {
+            spt_status: "unknown",
+            message: "Could not determine card payment availability.",
+        };
+        cachedCapabilities = {
+            value: fallback,
+            apiUrl,
+            expiresAt: Date.now() + 10_000,
+        };
+        return fallback;
+    }
+}

package/dist/core/config.d.ts

@@ -21,6 +21,7 @@ export interface Config {
     defaultWallet: string | null;
     defaultPaymentMethod?: string;
     card: CardConfig | null;
+    pendingCardSetupToken?: string | null;
     favorites: string[];
     /** Require user confirmation before spending. Default: true. Set false for headless/automated use. */
     confirmBeforeSpend: boolean;
@@ -73,6 +74,8 @@ export declare function getCardConfig(): CardConfig | null;
  * Save card configuration after setup.
  */
 export declare function setCardConfig(card: CardConfig | null): void;
+export declare function getPendingCardSetupToken(): string | null;
+export declare function setPendingCardSetupToken(token: string | null): void;
 /**
  * Resolve a payment method string to a wallet + chain.
  * Accepts: wallet ID, chain name, or "card".

package/dist/core/config.js

@@ -34,7 +34,9 @@ function migrateIfNeeded(raw) {
             userId: raw.userId ?? null,
             wallets: raw.wallets,
             defaultWallet: raw.defaultWallet ?? null,
+            defaultPaymentMethod: raw.defaultPaymentMethod ?? undefined,
             card: raw.card ?? null,
+            pendingCardSetupToken: r.pendingCardSetupToken ?? null,
             favorites: r.favorites ?? [],
             confirmBeforeSpend: r.confirmBeforeSpend !== false,
             defaultTipAmount: typeof r.defaultTipAmount === "number" ? r.defaultTipAmount : 0,
@@ -103,7 +105,9 @@ function migrateIfNeeded(raw) {
         userId: raw.userId ?? null,
         wallets,
         defaultWallet,
+        defaultPaymentMethod: raw.defaultPaymentMethod ?? undefined,
         card,
+        pendingCardSetupToken: null,
         favorites: [],
         confirmBeforeSpend: true,
         defaultTipAmount: 0,
@@ -124,6 +128,7 @@ export function getConfig() {
         wallets: [],
         defaultWallet: null,
         card: null,
+        pendingCardSetupToken: null,
         favorites: [],
         confirmBeforeSpend: true,
         defaultTipAmount: 0,
@@ -263,13 +268,30 @@ export function getCardConfig() {
  * Save card configuration after setup.
  */
 export function setCardConfig(card) {
+    const current = getConfig();
     if (card) {
-        saveConfig({ card, defaultPaymentMethod: "card" });
+        saveConfig({
+            card,
+            defaultPaymentMethod: "card",
+            pendingCardSetupToken: null,
+        });
     }
     else {
-        saveConfig({ card });
+        saveConfig({
+            card,
+            pendingCardSetupToken: null,
+            defaultPaymentMethod: current.defaultPaymentMethod === "card"
+                ? undefined
+                : current.defaultPaymentMethod,
+        });
     }
 }
+export function getPendingCardSetupToken() {
+    return getConfig().pendingCardSetupToken ?? null;
+}
+export function setPendingCardSetupToken(token) {
+    saveConfig({ pendingCardSetupToken: token });
+}
 /**
  * Resolve a payment method string to a wallet + chain.
  * Accepts: wallet ID, chain name, or "card".

package/dist/core/formatters.d.ts

@@ -43,6 +43,8 @@ interface RunResultLike {
     estimated_cost?: number;
     input_tokens?: number;
     tags?: string[];
+    consumption_mode?: string;
+    credit_pack_id?: string;
 }
 export declare function formatRunResult(result: RunResultLike, opts?: {
     paymentMethod?: string;

package/dist/core/formatters.js

@@ -110,6 +110,7 @@ export function formatRunResult(result, opts) {
     }
     // Summary line
     const cost = result.cost ?? result.estimated_cost;
+    const usedCreditPack = result.consumption_mode === "credit_pack";
     const status = result.status === "success" || result.status === "completed" ? "✓" : "✗";
     const agent = result.agent_name ?? result.agent_id ?? "";
     const costStr = cost != null ? `$${cost.toFixed(cost < 0.01 ? 6 : 2)}` : "";
@@ -119,7 +120,10 @@ export function formatRunResult(result, opts) {
     if (result.error_code) {
         lines.push(`Error: ${result.error_code}`);
     }
-    if (costStr) {
+    if (usedCreditPack) {
+        lines.push(`Covered by credit pack${result.credit_pack_id ? ` (${result.credit_pack_id})` : ""}`);
+    }
+    if (costStr && !usedCreditPack) {
         lines.push(`Paid: ${costStr}${method ? ` via ${method}` : ""}`);
     }
     if (result.job_id) {

package/dist/core/index.d.ts

@@ -1,6 +1,8 @@
 export * from "./api-client.js";
 export * from "./config.js";
 export * from "./payments.js";
+export * from "./principal.js";
+export * from "./passes.js";
 export * from "./ows-adapter.js";
 export * from "./formatters.js";
 export * from "./types.js";

package/dist/core/index.js

@@ -1,6 +1,8 @@
 export * from "./api-client.js";
 export * from "./config.js";
 export * from "./payments.js";
+export * from "./principal.js";
+export * from "./passes.js";
 export * from "./ows-adapter.js";
 export * from "./formatters.js";
 export * from "./types.js";

package/dist/core/ows-adapter.d.ts

@@ -8,6 +8,7 @@
  * ALL imports are dynamic so the MCP server works without OWS installed.
  */
 import type { LocalAccount } from "viem/accounts";
+import type { Keypair } from "@solana/web3.js";
 /**
  * Check whether the OWS native module can be loaded.
  */
@@ -19,17 +20,19 @@ export declare function isOwsAvailable(): Promise<boolean>;
  * @param chain    - OWS chain identifier (default "evm")
  */
 export declare function owsAccountFromWalletId(walletId: string, _chain?: string): Promise<LocalAccount>;
+export declare function owsSolanaKeypairFromWalletId(walletId: string): Promise<Keypair>;
+export declare function getOwsWalletAddress(walletId: string, chain?: "evm" | "solana"): Promise<string>;
 /**
  * Create a new OWS wallet and return its ID + EVM address.
  */
-export declare function createOwsWallet(name: string): Promise<{
+export declare function createOwsWallet(name: string, chain?: "evm" | "solana"): Promise<{
     walletId: string;
     address: string;
 }>;
 /**
  * Import an existing EVM private key into OWS.
  */
-export declare function importKeyToOws(privateKey: string, name: string): Promise<{
+export declare function importKeyToOws(privateKey: string, name: string, chain?: "evm" | "solana"): Promise<{
     walletId: string;
     address: string;
 }>;
@@ -41,3 +44,8 @@ export declare function listOwsWallets(): Promise<Array<{
     name: string;
     address: string;
 }>>;
+export declare function listOwsWalletsByChain(chain?: "evm" | "solana"): Promise<Array<{
+    id: string;
+    name: string;
+    address: string;
+}>>;

package/dist/core/ows-adapter.js

@@ -38,6 +38,26 @@ function findEvmAccount(wallet) {
     }
     return evm;
 }
+function findSolanaAccount(wallet) {
+    const solana = wallet.accounts.find((a) => a.chainId.startsWith("solana"));
+    if (!solana) {
+        throw new Error(`Wallet "${wallet.name}" (${wallet.id}) has no Solana account.`);
+    }
+    return solana;
+}
+function ed25519HexToBytes(privateKeyHex) {
+    return Uint8Array.from(Buffer.from(privateKeyHex, "hex"));
+}
+function keypairFromEd25519Hex(privateKeyHex, KeypairCtor) {
+    const bytes = ed25519HexToBytes(privateKeyHex);
+    if (bytes.length === 32) {
+        return KeypairCtor.fromSeed(bytes);
+    }
+    if (bytes.length === 64) {
+        return KeypairCtor.fromSecretKey(bytes);
+    }
+    throw new Error(`Unsupported ed25519 key length: ${bytes.length} bytes.`);
+}
 // ── Public API ───────────────────────────────────────────────────
 /**
  * Check whether the OWS native module can be loaded.
@@ -73,38 +93,62 @@ export async function owsAccountFromWalletId(walletId, _chain) {
     const { privateKeyToAccount } = await import("viem/accounts");
     return privateKeyToAccount(`0x${keys.secp256k1}`);
 }
+export async function owsSolanaKeypairFromWalletId(walletId) {
+    const ows = await loadOws();
+    const wallet = ows.getWallet(walletId);
+    findSolanaAccount(wallet);
+    const exported = ows.exportWallet(walletId);
+    const keys = JSON.parse(exported);
+    if (!keys.ed25519) {
+        throw new Error(`Wallet "${wallet.name}" has no ed25519 key for Solana signing.`);
+    }
+    const { Keypair } = await import("@solana/web3.js");
+    return keypairFromEd25519Hex(keys.ed25519, Keypair);
+}
+export async function getOwsWalletAddress(walletId, chain = "evm") {
+    const ows = await loadOws();
+    const wallet = ows.getWallet(walletId);
+    return chain === "solana"
+        ? findSolanaAccount(wallet).address
+        : findEvmAccount(wallet).address;
+}
 /**
  * Create a new OWS wallet and return its ID + EVM address.
  */
-export async function createOwsWallet(name) {
+export async function createOwsWallet(name, chain = "evm") {
     const ows = await loadOws();
     const wallet = ows.createWallet(name);
-    const evmAccount = findEvmAccount(wallet);
-    return { walletId: wallet.id, address: evmAccount.address };
+    const account = chain === "solana" ? findSolanaAccount(wallet) : findEvmAccount(wallet);
+    return { walletId: wallet.id, address: account.address };
 }
 /**
  * Import an existing EVM private key into OWS.
  */
-export async function importKeyToOws(privateKey, name) {
+export async function importKeyToOws(privateKey, name, chain = "evm") {
     const ows = await loadOws();
     const normalizedKey = privateKey.startsWith("0x")
         ? privateKey.slice(2)
         : privateKey;
-    const wallet = ows.importWalletPrivateKey(name, normalizedKey, null, null, "evm");
-    const evmAccount = findEvmAccount(wallet);
-    return { walletId: wallet.id, address: evmAccount.address };
+    const wallet = ows.importWalletPrivateKey(name, normalizedKey, null, null, chain);
+    const account = chain === "solana" ? findSolanaAccount(wallet) : findEvmAccount(wallet);
+    return { walletId: wallet.id, address: account.address };
 }
 /**
  * List all OWS wallets that have an EVM account.
  */
 export async function listOwsWallets() {
+    return listOwsWalletsByChain("evm");
+}
+export async function listOwsWalletsByChain(chain = "evm") {
     const ows = await loadOws();
     const wallets = ows.listWallets();
     const result = [];
     for (const w of wallets) {
-        const evm = w.accounts.find((a) => a.chainId.startsWith("eip155") || a.chainId.startsWith("evm"));
-        if (evm) {
-            result.push({ id: w.id, name: w.name, address: evm.address });
+        const account = chain === "solana"
+            ? w.accounts.find((a) => a.chainId.startsWith("solana"))
+            : w.accounts.find((a) => a.chainId.startsWith("eip155") || a.chainId.startsWith("evm"));
+        if (account) {
+            result.push({ id: w.id, name: w.name, address: account.address });
         }
     }
     return result;

package/dist/core/passes.d.ts

@@ -0,0 +1,40 @@
+import type { AgentRecord } from "./types.js";
+export interface CreditPackOffer {
+    pack_id: string;
+    label: string;
+    included_units: number;
+    price_usd: string;
+    effective_price_per_unit_usd?: string;
+}
+export interface CreditPackRecord {
+    id: string;
+    status: string;
+    unit_type: string;
+    included_units: number;
+    remaining_units: number;
+    price_usd: string;
+    purchased_at: string;
+    pack?: {
+        name?: string | null;
+        key?: string | null;
+    };
+}
+export interface CreditPackProgramInfo {
+    unit_type?: string;
+    packs?: Array<{
+        key?: string;
+        name?: string;
+        included_units?: number;
+        price_usd?: string;
+    }>;
+}
+export interface CreditPackInventory {
+    consumer_principal: string | null;
+    offers: CreditPackOffer[];
+    balances: CreditPackRecord[];
+}
+export declare function getCreditPackProgram(agent: AgentRecord): CreditPackProgramInfo | null;
+export declare function getCreditPackInventory(agentId: string): Promise<CreditPackInventory | null>;
+export declare function getActiveCreditPack(inventory: CreditPackInventory | null): CreditPackRecord | null;
+export declare function formatCreditPackOffer(offer: CreditPackOffer): string;
+export declare function formatCreditPack(pack: CreditPackRecord): string;

package/dist/core/passes.js

@@ -0,0 +1,32 @@
+import { apiGet } from "./api-client.js";
+export function getCreditPackProgram(agent) {
+    const payment = (agent.payment ?? {});
+    const creditPacks = payment.credit_packs;
+    return creditPacks ?? null;
+}
+export async function getCreditPackInventory(agentId) {
+    try {
+        return await apiGet(`/agents/${agentId}/credit-packs`, { ensureConsumerPrincipal: true });
+    }
+    catch {
+        return null;
+    }
+}
+export function getActiveCreditPack(inventory) {
+    if (!inventory)
+        return null;
+    return inventory.balances
+        .filter((pack) => pack.status === "active" && pack.remaining_units > 0)
+        .sort((a, b) => new Date(a.purchased_at).getTime() - new Date(b.purchased_at).getTime())[0] ?? null;
+}
+export function formatCreditPackOffer(offer) {
+    const unitPrice = offer.effective_price_per_unit_usd
+        ? ` ($${Number(offer.effective_price_per_unit_usd).toFixed(2)}/unit)`
+        : "";
+    return `${offer.label} — ${offer.included_units} units for $${offer.price_usd}${unitPrice}`;
+}
+export function formatCreditPack(pack) {
+    const label = pack.pack?.name ?? pack.pack?.key ?? "Credit Pack";
+    const statusPrefix = pack.status === "active" ? "" : `${pack.status} • `;
+    return `${label}: ${statusPrefix}${pack.remaining_units}/${pack.included_units} ${pack.unit_type}s remaining`;
+}

package/dist/core/payments.d.ts

@@ -9,6 +9,7 @@
  * Users can configure multiple wallets with different chains and select
  * which to use per-request via `--pay-with <wallet-id|chain|card>`.
  */
+import type { AgentRecord } from "./types.js";
 /**
  * Returns a payment-aware fetch for a specific method, or the best
  * available method if none is specified.
@@ -21,6 +22,11 @@ export declare function getPaymentFetch(method?: string): Promise<typeof fetch>;
  * (with default wallet's default chain first) + "card" if configured.
  */
 export declare function getConfiguredMethods(): string[];
+/**
+ * Normalize a requested payment method into the MCP-visible method identifier.
+ * Accepts chain names, wallet IDs, or "card".
+ */
+export declare function normalizePaymentMethod(method: string): string | null;
 /**
  * Human-friendly display name for a payment method identifier.
  */
@@ -31,6 +37,8 @@ export declare function paymentMethodDisplayName(method: string): string;
  * (tempo_usdc, base_usdc, stripe_card).
  */
 export declare function getAcceptedPaymentMethods(): string[];
+export declare function toRegistryPaymentMethod(method: string): string | null;
+export declare function getCompatiblePaymentMethods(agent: Pick<AgentRecord, "payment"> | null | undefined, configuredMethods?: string[]): string[];
 /**
  * Check whether any payment method is configured.
  */