@agentwonderland/mcp 0.1.22 → 0.1.24

package/src/core/card-setup.ts

@@ -1,51 +1,78 @@
-import QRCode from "qrcode";
-import { apiPost, apiGet } from "./api-client.js";
-import { getApiUrl, getCardConfig, setCardConfig } from "./config.js";
+import { apiPost, apiGet, ApiError } from "./api-client.js";
+import {
+  getApiUrl,
+  setCardConfig,
+  getPendingCardSetupToken,
+  setPendingCardSetupToken,
+} from "./config.js";
+
+export interface CardSetupResult {
+  last4: string;
+  brand: string;
+  consumerToken: string;
+}
+
+export interface CardCapabilities {
+  spt_status: "enabled" | "unavailable" | "unknown";
+  message?: string;
+}
+
+let cachedCapabilities:
+  | { value: CardCapabilities; expiresAt: number; apiUrl: string }
+  | null = null;
+
+function buildCardSetupUrl(token: string): string {
+  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(): Promise<{
-  qr: string;
+export async function getOrCreatePendingCardSetup(): Promise<{
   url: string;
   token: string;
+  isNew: boolean;
 }> {
-  const { url: _checkoutUrl, token } = await apiPost<{ url: string; token: string }>("/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,
-  });
+  const pendingToken = getPendingCardSetupToken();
+  if (pendingToken) {
+    const url = buildCardSetupUrl(pendingToken);
+    return {
+      url,
+      token: pendingToken,
+      isNew: false,
+    };
+  }
 
-  // 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");
+  const { token } = await apiPost<{ url: string; token: string }>("/card/setup", {});
+  setPendingCardSetupToken(token);
+  const url = buildCardSetupUrl(token);
 
-  return { qr, url: shortUrl, 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: string, url: string): string[] {
+export function formatCardSetupBlocks(url: string): string[] {
   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"),
   ];
 }
@@ -56,39 +83,89 @@ export function formatCardSetupBlocks(qr: string, url: string): string[] {
 export async function pollCardSetup(
   token: string,
   timeoutMs = 120_000,
-): Promise<{ last4: string; brand: string; consumerToken: string } | null> {
+): Promise<CardSetupResult | null> {
   const deadline = Date.now() + timeoutMs;
 
   while (Date.now() < deadline) {
-    await new Promise((r) => setTimeout(r, 3000));
     try {
       const status = await apiGet<{
         status: string;
         card_last4?: string;
         card_brand?: string;
         consumer_token?: string;
+        payment_method_id?: string;
       }>(`/card/status?token=${token}`);
 
       if (status.status === "complete" && status.consumer_token) {
-        const card = {
+        const card: CardSetupResult = {
           last4: status.card_last4 ?? "????",
           brand: status.card_brand ?? "card",
           consumerToken: status.consumer_token,
         };
 
-        // Persist to config
+        // Persist to config (including paymentMethodId for mppx stripe charge)
         setCardConfig({
           consumerToken: card.consumerToken,
+          paymentMethodId: status.payment_method_id,
           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(): Promise<CardCapabilities> {
+  const apiUrl = getApiUrl();
+  if (cachedCapabilities && cachedCapabilities.apiUrl === apiUrl && cachedCapabilities.expiresAt > Date.now()) {
+    return cachedCapabilities.value;
+  }
+
+  try {
+    const capabilities = await apiGet<CardCapabilities>("/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,
+      } satisfies CardCapabilities;
+      cachedCapabilities = {
+        value: fallback,
+        apiUrl,
+        expiresAt: Date.now() + 10_000,
+      };
+      return fallback;
+    }
+    const fallback = {
+      spt_status: "unknown",
+      message: "Could not determine card payment availability.",
+    } satisfies CardCapabilities;
+    cachedCapabilities = {
+      value: fallback,
+      apiUrl,
+      expiresAt: Date.now() + 10_000,
+    };
+    return fallback;
+  }
+}

package/src/core/config.ts

@@ -9,7 +9,7 @@ export interface WalletEntry {
   keyType: "evm" | "ows"; // key format: raw EVM key or OWS-managed wallet
   key?: string;        // private key (legacy / raw EVM only)
   owsWalletId?: string; // OWS wallet reference (when keyType === "ows")
-  chains: string[];    // enabled chains: "tempo", "base"
+  chains: string[];    // enabled chains: "tempo", "base", "solana"
   defaultChain?: string; // which chain to use by default for this wallet
   label?: string;      // user-friendly name
 }
@@ -27,7 +27,9 @@ export interface Config {
   userId: string | null;
   wallets: WalletEntry[];
   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;
@@ -79,6 +81,7 @@ interface LegacyConfig {
   wallets?: WalletEntry[];
   defaultWallet?: string | null;
   card?: CardConfig | null;
+  pendingCardSetupToken?: string | null;
 }
 
 /**
@@ -95,7 +98,9 @@ function migrateIfNeeded(raw: LegacyConfig): Config {
       userId: raw.userId ?? null,
       wallets: raw.wallets,
       defaultWallet: raw.defaultWallet ?? null,
+      defaultPaymentMethod: raw.defaultPaymentMethod ?? undefined,
       card: raw.card ?? null,
+      pendingCardSetupToken: (r.pendingCardSetupToken as string | null | undefined) ?? null,
       favorites: r.favorites as string[] ?? [],
       confirmBeforeSpend: r.confirmBeforeSpend !== false,
       defaultTipAmount: typeof r.defaultTipAmount === "number" ? r.defaultTipAmount : 0,
@@ -167,7 +172,9 @@ function migrateIfNeeded(raw: LegacyConfig): Config {
     userId: raw.userId ?? null,
     wallets,
     defaultWallet,
+    defaultPaymentMethod: raw.defaultPaymentMethod ?? undefined,
     card,
+    pendingCardSetupToken: null,
     favorites: [],
     confirmBeforeSpend: true,
     defaultTipAmount: 0,
@@ -192,6 +199,7 @@ export function getConfig(): Config {
     wallets: [],
     defaultWallet: null,
     card: null,
+    pendingCardSetupToken: null,
     favorites: [],
     confirmBeforeSpend: true,
     defaultTipAmount: 0,
@@ -350,7 +358,30 @@ export function getCardConfig(): CardConfig | null {
  * Save card configuration after setup.
  */
 export function setCardConfig(card: CardConfig | null): void {
-  saveConfig({ card });
+  const current = getConfig();
+  if (card) {
+    saveConfig({
+      card,
+      defaultPaymentMethod: "card",
+      pendingCardSetupToken: null,
+    });
+  } else {
+    saveConfig({
+      card,
+      pendingCardSetupToken: null,
+      defaultPaymentMethod: current.defaultPaymentMethod === "card"
+        ? undefined
+        : current.defaultPaymentMethod,
+    });
+  }
+}
+
+export function getPendingCardSetupToken(): string | null {
+  return getConfig().pendingCardSetupToken ?? null;
+}
+
+export function setPendingCardSetupToken(token: string | null): void {
+  saveConfig({ pendingCardSetupToken: token });
 }
 
 /**

package/src/core/formatters.ts

@@ -118,6 +118,8 @@ interface RunResultLike {
   estimated_cost?: number;
   input_tokens?: number;
   tags?: string[];
+  consumption_mode?: string;
+  credit_pack_id?: string;
 }
 
 export function formatRunResult(result: RunResultLike, opts?: { paymentMethod?: string }): string {
@@ -147,6 +149,7 @@ export function formatRunResult(result: RunResultLike, opts?: { paymentMethod?:
 
   // 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)}` : "";
@@ -157,7 +160,10 @@ export function formatRunResult(result: RunResultLike, opts?: { paymentMethod?:
   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/src/core/index.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/src/core/ows-adapter.ts

@@ -10,6 +10,7 @@
 
 import type { LocalAccount } from "viem/accounts";
 import type { Hex } from "viem";
+import type { Keypair } from "@solana/web3.js";
 
 // Note: OWS provides encrypted key storage at rest (~/.ows/, AES-256-GCM).
 // For EVM signing, we export the secp256k1 key and use viem's native
@@ -127,6 +128,33 @@ function findEvmAccount(
   return evm;
 }
 
+function findSolanaAccount(
+  wallet: OwsWalletInfo,
+): OwsAccountInfo {
+  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: string): Uint8Array {
+  return Uint8Array.from(Buffer.from(privateKeyHex, "hex"));
+}
+
+function keypairFromEd25519Hex(privateKeyHex: string, KeypairCtor: typeof import("@solana/web3.js").Keypair): Keypair {
+  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 ───────────────────────────────────────────────────
 
 /**
@@ -169,16 +197,45 @@ export async function owsAccountFromWalletId(
   return privateKeyToAccount(`0x${keys.secp256k1}` as Hex);
 }
 
+export async function owsSolanaKeypairFromWalletId(
+  walletId: string,
+): Promise<Keypair> {
+  const ows = await loadOws();
+  const wallet = ows.getWallet(walletId);
+  findSolanaAccount(wallet);
+
+  const exported = ows.exportWallet(walletId);
+  const keys = JSON.parse(exported) as { secp256k1?: string; ed25519?: string };
+  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: string,
+  chain: "evm" | "solana" = "evm",
+): Promise<string> {
+  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: string,
+  chain: "evm" | "solana" = "evm",
 ): Promise<{ walletId: string; address: string }> {
   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 };
 }
 
 /**
@@ -187,6 +244,7 @@ export async function createOwsWallet(
 export async function importKeyToOws(
   privateKey: string,
   name: string,
+  chain: "evm" | "solana" = "evm",
 ): Promise<{ walletId: string; address: string }> {
   const ows = await loadOws();
   const normalizedKey = privateKey.startsWith("0x")
@@ -197,10 +255,10 @@ export async function importKeyToOws(
     normalizedKey,
     null,
     null,
-    "evm",
+    chain,
   );
-  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 };
 }
 
 /**
@@ -209,14 +267,22 @@ export async function importKeyToOws(
 export async function listOwsWallets(): Promise<
   Array<{ id: string; name: string; address: string }>
 > {
+  return listOwsWalletsByChain("evm");
+}
+
+export async function listOwsWalletsByChain(
+  chain: "evm" | "solana" = "evm",
+): Promise<Array<{ id: string; name: string; address: string }>> {
   const ows = await loadOws();
   const wallets = ows.listWallets();
   const result: Array<{ id: string; name: string; address: string }> = [];
 
   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 });
     }
   }
 

package/src/core/passes.ts

@@ -0,0 +1,74 @@
+import { apiGet } from "./api-client.js";
+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 function getCreditPackProgram(agent: AgentRecord): CreditPackProgramInfo | null {
+  const payment = (agent.payment ?? {}) as Record<string, unknown>;
+  const creditPacks = payment.credit_packs as CreditPackProgramInfo | null | undefined;
+  return creditPacks ?? null;
+}
+
+export async function getCreditPackInventory(agentId: string): Promise<CreditPackInventory | null> {
+  try {
+    return await apiGet<CreditPackInventory>(`/agents/${agentId}/credit-packs`, { ensureConsumerPrincipal: true });
+  } catch {
+    return null;
+  }
+}
+
+export function getActiveCreditPack(inventory: CreditPackInventory | null): CreditPackRecord | null {
+  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: CreditPackOffer): string {
+  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: CreditPackRecord): string {
+  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`;
+}