@agentwonderland/mcp 0.1.25 → 0.1.27

package/src/tools/__tests__/wallet.test.ts

@@ -0,0 +1,289 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+type WalletEntry = {
+  id: string;
+  keyType: "evm" | "ows";
+  key?: string;
+  owsWalletId?: string;
+  chains: string[];
+  defaultChain?: string;
+  label?: string;
+};
+
+type CardConfig = {
+  consumerToken: string;
+  paymentMethodId?: string;
+  last4: string;
+  brand: string;
+} | null;
+
+type WalletToolResult = {
+  content: Array<{ type: "text"; text: string }>;
+};
+
+const state = vi.hoisted(() => ({
+  wallets: [] as WalletEntry[],
+  addedWallets: [] as WalletEntry[],
+  card: null as CardConfig,
+  pendingCardSetupToken: null as string | null,
+  spendPolicies: {} as Record<string, unknown>,
+  consumerPrincipal: "did:pkh:eip155:8453:0xabc",
+  owsAvailable: true,
+  owsWallets: [] as Array<{ id: string; name: string; address: string }>,
+  owsWalletsByChain: [] as Array<{ id: string; name: string; address: string }>,
+  createdWalletCalls: [] as Array<{ name: string; chain: "evm" | "solana" }>,
+  importWalletCalls: [] as Array<{ privateKey: string; name: string; chain: "evm" | "solana" }>,
+  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: [] as Array<{ token: string; timeoutMs: number }>,
+  pollCardSetupResult: null as
+    | {
+      brand: string;
+      last4: string;
+      consumerToken: string;
+    }
+    | null,
+  setCardConfigCalls: [] as CardConfig[],
+}));
+
+vi.mock("../../core/config.js", () => ({
+  addWallet: (wallet: WalletEntry) => {
+    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: string) => state.spendPolicies[walletId] ?? null,
+  getWallets: () => state.wallets,
+  setCardConfig: (card: CardConfig) => {
+    state.card = card;
+    state.setCardConfigCalls.push(card);
+  },
+  setSpendPolicy: (walletId: string, policy: unknown) => {
+    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: string, timeoutMs: number) => {
+    state.pollCardSetupCalls.push({ token, timeoutMs });
+    return state.pollCardSetupResult;
+  },
+}));
+
+vi.mock("../../core/ows-adapter.js", () => ({
+  createOwsWallet: async (name: string, chain: "evm" | "solana") => {
+    state.createdWalletCalls.push({ name, chain });
+    return state.createdWalletResult;
+  },
+  importKeyToOws: async (privateKey: string, name: string, chain: "evm" | "solana") => {
+    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(): void {
+  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(): Promise<(args: Record<string, unknown>) => Promise<WalletToolResult>> {
+  const tools = new Map<string, (args: Record<string, unknown>) => Promise<WalletToolResult>>();
+  const server = {
+    tool: (
+      name: string,
+      _description: string,
+      _schema: unknown,
+      handler: (args: Record<string, unknown>) => Promise<WalletToolResult>,
+    ) => {
+      tools.set(name, handler);
+    },
+  } as unknown as McpServer;
+
+  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: WalletToolResult): string {
+  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/src/tools/_payment-confirmation.ts

@@ -47,6 +47,6 @@ export function formatPaymentChoicePrompt(
     ...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/src/tools/agent-info.ts

@@ -31,14 +31,27 @@ export function registerAgentInfoTools(server: McpServer): void {
         }>;
       } | null | undefined;
 
+      const totalJobs = (s.completedJobs ?? a.totalExecutions ?? 0) as number;
+      const acceptedPayments = (payment.accepted_payments as string[] | undefined) ?? [];
+      const paymentLabelMap: Record<string, string> = {
+        tempo_usdc: "tempo",
+        base_usdc: "base",
+        solana_usdc: "solana",
+        stripe_card: "card",
+      };
+      const paymentLabels = acceptedPayments.map((m) => paymentLabelMap[m] ?? m);
+
       const lines = [
         `${a.name}`,
-        `${stars(a.avgRating ?? (s.avgRating as number))} (${s.ratingCount ?? 0} reviews) • ${compactNumber((s.completedJobs ?? a.totalExecutions ?? 0) as number)} jobs`,
+        `${stars(a.avgRating ?? (s.avgRating as number))} (${s.ratingCount ?? 0} reviews) • ${compactNumber(totalJobs)} jobs`,
         "",
         (a.description as string) ?? "",
         "",
         `Pricing: ${formatPrice(a.pricePerRunUsd)}`,
-        `Reliability: ${a.successRate != null ? (Number(a.successRate) * 100).toFixed(0) + "%" : "N/A"}`,
+        ...(paymentLabels.length > 0 ? [`Accepted payments: ${paymentLabels.join(", ")}`] : []),
+        ...(totalJobs > 0 && a.successRate != null
+          ? [`Reliability: ${(Number(a.successRate) * 100).toFixed(0)}% (${compactNumber(totalJobs)} runs)`]
+          : []),
         `Avg latency: ${(a.avgResponseTimeMs as number) != null ? a.avgResponseTimeMs + "ms" : "N/A"}`,
         ...(() => {
           const lastActive = formatLastActive(a.lastActiveAt as string | null);
@@ -104,40 +117,4 @@ export function registerAgentInfoTools(server: McpServer): void {
       return text(lines.join("\n"));
     },
   );
-
-  // ── compare_agents ──────────────────────────────────────────────
-  server.tool(
-    "compare_agents",
-    "Compare multiple agents side-by-side on rating, price, success rate, and job count.",
-    {
-      agent_ids: z
-        .array(z.string())
-        .min(2)
-        .max(5)
-        .describe("Agent IDs to compare (2-5)"),
-    },
-    async ({ agent_ids }) => {
-      const agents = await Promise.all(
-        agent_ids.map((id) => apiGet<AgentRecord>(`/agents/${id}`)),
-      );
-
-      const header = "Agent Comparison:\n";
-      const lines = agents.map((a) => {
-        const s = (a.stats ?? {}) as Record<string, unknown>;
-        const rating = a.avgRating ?? (s.avgRating as number);
-        const jobs = (s.completedJobs ?? a.totalExecutions ?? 0) as number;
-        const tipCount = (s.tipCount ?? 0) as number;
-        return [
-          `  ${a.name}`,
-          `  ${stars(rating)} (${s.ratingCount ?? 0} reviews)${tipCount > 0 ? ` • ${tipCount} tips` : ""}`,
-          `  ${compactNumber(jobs)} jobs • ${formatPrice(a.pricePerRunUsd)}`,
-          `  Success: ${a.successRate != null ? (Number(a.successRate) * 100).toFixed(0) + "%" : "N/A"}`,
-          `  ${agentWebUrl(a.id)}`,
-          "",
-        ].join("\n");
-      });
-
-      return text(header + lines.join("\n"));
-    },
-  );
 }

package/src/tools/jobs.ts

@@ -9,6 +9,26 @@ function text(t: string) {
   return { content: [{ type: "text" as const, text: t }] };
 }
 
+async function getConsumerWalletAddresses(): Promise<string[]> {
+  const addresses = new Set<string>();
+  for (const chain of ["tempo", "base", "solana"]) {
+    const addr = await getWalletAddress(chain);
+    if (addr) addresses.add(addr);
+  }
+  return [...addresses];
+}
+
+function formatRelativeTime(iso: string | null | undefined): string {
+  if (!iso) return "";
+  const t = new Date(iso).getTime();
+  if (!Number.isFinite(t)) return "";
+  const diffSec = Math.max(0, Math.floor((Date.now() - t) / 1000));
+  if (diffSec < 60) return `${diffSec}s ago`;
+  if (diffSec < 3600) return `${Math.floor(diffSec / 60)}m ago`;
+  if (diffSec < 86400) return `${Math.floor(diffSec / 3600)}h ago`;
+  return `${Math.floor(diffSec / 86400)}d ago`;
+}
+
 export function registerJobTools(server: McpServer): void {
   // ── get_job ─────────────────────────────────────────────────────
   server.tool(
@@ -18,7 +38,25 @@ export function registerJobTools(server: McpServer): void {
       job_id: z.string().describe("Job ID (UUID)"),
     },
     async ({ job_id }) => {
-      const result = await apiGet<Record<string, unknown>>(`/jobs/${job_id}`);
+      const walletLookup = !isAuthenticated() && hasWalletConfigured();
+      const addresses = walletLookup ? await getConsumerWalletAddresses() : [""];
+
+      let result: Record<string, unknown> | null = null;
+      for (const addr of addresses) {
+        const url = addr ? `/jobs/${job_id}?wallet=${encodeURIComponent(addr)}` : `/jobs/${job_id}`;
+        try {
+          result = await apiGet<Record<string, unknown>>(url);
+          break;
+        } catch (err) {
+          const status = (err as { status?: number }).status;
+          if (status !== 404) throw err;
+        }
+      }
+
+      if (!result) {
+        return text(`Job ${job_id} not found. Either the job ID is wrong or it was paid with a wallet not configured here.`);
+      }
+
       if (result.status === "processing") {
         return text(`Job ${job_id} is still processing...`);
       }
@@ -26,26 +64,46 @@ export function registerJobTools(server: McpServer): void {
     },
   );
 
-  // ── list_jobs (renamed from list_my_jobs) ───────────────────────
+  // ── list_jobs ───────────────────────────────────────────────────
   server.tool(
     "list_jobs",
-    "List your recent jobs with status, cost, and agent info.",
+    "List your recent jobs across all configured payment wallets, with status, cost, agent, method, and age.",
     {
-      limit: z.coerce.number().optional().default(10).describe("Max results (1-50)"),
+      limit: z.coerce.number().int().min(1).max(50).optional().default(10).describe("Max results (1-50)"),
     },
     async ({ limit }) => {
-      let url = `/jobs?limit=${limit ?? 10}`;
+      const requestedLimit = limit ?? 10;
+      const walletLookup = !isAuthenticated() && hasWalletConfigured();
+      const addresses = walletLookup ? await getConsumerWalletAddresses() : [""];
 
-      // If not authenticated via API key, use wallet address for lookup
-      if (!isAuthenticated() && hasWalletConfigured()) {
-        const address = await getWalletAddress();
-        if (address) {
-          url += `&wallet=${encodeURIComponent(address)}`;
+      const seen = new Set<string>();
+      const collected: Array<Record<string, unknown>> = [];
+      for (const addr of addresses) {
+        const url = addr
+          ? `/jobs?wallet=${encodeURIComponent(addr)}&limit=${requestedLimit}`
+          : `/jobs?limit=${requestedLimit}`;
+        try {
+          const jobs = await apiGet<Array<Record<string, unknown>>>(url);
+          for (const j of jobs) {
+            const id = j.job_id as string;
+            if (!seen.has(id)) {
+              seen.add(id);
+              collected.push(j);
+            }
+          }
+        } catch {
+          // Skip address that errored; continue with others.
         }
       }
 
-      const jobs = await apiGet<Array<Record<string, unknown>>>(url);
-      if (jobs.length === 0) return text("No jobs found.");
+      if (collected.length === 0) return text("No jobs found.");
+
+      collected.sort((a, b) => {
+        const aTime = new Date((a.created_at as string) ?? 0).getTime();
+        const bTime = new Date((b.created_at as string) ?? 0).getTime();
+        return bTime - aTime;
+      });
+      const jobs = collected.slice(0, requestedLimit);
 
       const lines = [`Recent jobs (${jobs.length}):`];
       for (const j of jobs) {
@@ -55,12 +113,16 @@ export function registerJobTools(server: McpServer): void {
             : j.status === "processing"
               ? "\u2026"
               : "\u2717";
-        const cost =
-          j.estimated_cost != null
-            ? `$${Number(j.estimated_cost).toFixed(4)}`
-            : "";
+        const amount = (j.settled_amount ?? j.estimated_cost) as string | number | undefined;
+        const cost = amount != null ? `$${Number(amount).toFixed(4)}` : "";
+        const method = ((j.settlement_trace as Record<string, unknown> | undefined)
+          ?.payment_attempt as { payment_method?: string } | undefined)?.payment_method;
+        const methodLabel = method ? `[${method.replace(/_usdc$/, "").replace("stripe_", "")}]` : "";
+        const shortId = (j.job_id as string)?.slice(0, 8);
+        const shortAgent = j.agent_id ? String(j.agent_id).slice(0, 8) : "?";
+        const when = formatRelativeTime(j.created_at as string | null);
         lines.push(
-          `  ${status} ${(j.job_id as string)?.slice(0, 8)}\u2026 ${j.agent_id ? String(j.agent_id).slice(0, 8) + "\u2026" : ""} ${cost}`,
+          `  ${status} ${shortId} agent=${shortAgent} ${cost} ${methodLabel} ${when}`.trimEnd(),
         );
       }
       return text(lines.join("\n"));

package/src/tools/passes.ts

@@ -4,6 +4,7 @@ import { apiGet, apiPostWithPayment } from "../core/api-client.js";
 import {
   formatCreditPack,
   formatCreditPackOffer,
+  getCreditPackInventory,
   getCreditPackProgram,
 } from "../core/passes.js";
 import {
@@ -11,9 +12,10 @@ import {
   getConfiguredMethods,
   hasWalletConfigured,
   normalizePaymentMethod,
+  isCardPaymentEnabled,
 } from "../core/payments.js";
 import { requiresSpendConfirmation } from "../core/config.js";
-import { ensureConsumerPrincipal } from "../core/principal.js";
+import { ensureConsumerPrincipalForMethod } from "../core/principal.js";
 import { getOrCreatePendingCardSetup, formatCardSetupBlocks } from "../core/card-setup.js";
 import {
   formatPaymentChoicePrompt,
@@ -70,21 +72,29 @@ export function registerPassTools(server: McpServer): void {
     },
     async ({ agent_id, pack_id, pay_with, confirmed }) => {
       if (!hasWalletConfigured()) {
-        try {
-          const { url } = await getOrCreatePendingCardSetup();
-          return multiText(...formatCardSetupBlocks(url));
-        } catch {
-          return text(
-            "No payment method configured.\n\n" +
-            "To add a credit card: wallet_setup({ action: \"add-card\" })\n" +
-            "To use crypto: wallet_setup({ action: \"create\" })",
-          );
+        if (isCardPaymentEnabled()) {
+          try {
+            const { url } = await getOrCreatePendingCardSetup();
+            return multiText(...formatCardSetupBlocks(url));
+          } catch {
+            // Fall through to the setup message below.
+          }
         }
+        const setupLines = [
+          "No payment method configured.",
+          "",
+          "Supported rails: Tempo USDC, Base USDC, Solana USDC.",
+          "Run wallet_setup({ action: \"create\" }) to create a crypto wallet,",
+          "or wallet_setup({ action: \"import\" }) with an existing key.",
+        ];
+        if (isCardPaymentEnabled()) {
+          setupLines.push("", "Or wallet_setup({ action: \"add-card\" }) to connect a credit card.");
+        }
+        return text(setupLines.join("\n"));
       }
 
       const agent = await getAgent(agent_id);
       const agentName = agent.name ?? agent_id;
-      const principal = await ensureConsumerPrincipal();
       const program = getCreditPackProgram(agent);
       const offers = (program?.packs ?? [])
         .map((pack) => findOffer(agent, pack.key ?? ""))
@@ -155,6 +165,7 @@ export function registerPassTools(server: McpServer): void {
       }
 
       const method = resolveConfirmationMethod(pay_with, pending?.method, compatibleMethods);
+      const principal = await ensureConsumerPrincipalForMethod(method);
       if (requiresSpendConfirmation() && !confirmed) {
         pendingCreditPackPurchases.set(agent.id, {
           agentId: agent.id,
@@ -192,7 +203,8 @@ export function registerPassTools(server: McpServer): void {
         formatCreditPack(result.credit_pack),
         `Consumer principal: ${result.consumer_principal}`,
         "",
-        "Future runs through run_agent will automatically use this credit pack while units remain.",
+        "Future runs for this agent will automatically use this credit pack while units remain.",
+        "That includes run_agent, and solve whenever it selects this same agent.",
       ].join("\n"));
     },
   );
@@ -202,10 +214,14 @@ export function registerPassTools(server: McpServer): void {
     "Show discounted credit-pack offers for an agent plus any balances available under the current consumer principal.",
     {
       agent_id: z.string().describe("Agent ID (UUID, slug, or name)"),
+      pay_with: z.string().optional().describe("Optional payment method context used to inspect the matching consumer principal."),
     },
-    async ({ agent_id }) => {
+    async ({ agent_id, pay_with }) => {
       const agent = await getAgent(agent_id);
-      const result = await apiGet<CreditPackInventory>(`/agents/${agent.id}/credit-packs`, { ensureConsumerPrincipal: true });
+      const result = await getCreditPackInventory(agent.id, pay_with);
+      if (!result) {
+        return text(`Could not load credit-pack inventory for ${agent.name}.`);
+      }
 
       const lines = [
         `Credit packs for ${agent.name}`,