@agentwonderland/mcp 0.1.23 → 0.1.25

package/src/resources/wallet.ts

@@ -1,11 +1,13 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { getWallets, getCardConfig } from "../core/config.js";
+import { getWallets, getCardConfig, getPendingCardSetupToken } from "../core/config.js";
+import { getCardCapabilities } from "../core/card-setup.js";
 import { getWalletAddress, getConfiguredMethods } from "../core/payments.js";
 
 export function registerWalletResources(server: McpServer) {
   server.resource("wallet-config", "aw://wallet", async () => {
     const wallets = getWallets();
     const card = getCardConfig();
+    const pendingCardSetupToken = getPendingCardSetupToken();
     const methods = getConfiguredMethods();
 
     const lines = ["Wallet Configuration", ""];
@@ -16,6 +18,11 @@ export function registerWalletResources(server: McpServer) {
     }
     if (card) {
       lines.push(`Card: ${card.brand} ****${card.last4}`);
+      const capabilities = await getCardCapabilities();
+      lines.push(`Card MPP: ${capabilities.spt_status}${capabilities.message ? ` — ${capabilities.message}` : ""}`);
+    }
+    if (pendingCardSetupToken) {
+      lines.push("Card setup: pending confirmation");
     }
     lines.push("", `Configured methods: ${methods.join(", ") || "none"}`);
 

package/src/tools/__tests__/_payment-confirmation.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  formatPaymentChoicePrompt,
+  formatRunConfirmationCommand,
+  formatSolveConfirmationCommand,
+  makeSolvePendingKey,
+  resolveConfirmationMethod,
+} from "../_payment-confirmation.js";
+
+describe("payment confirmation helpers", () => {
+  it("prefers the explicit method, then pending, then configured default", () => {
+    expect(resolveConfirmationMethod("card", "tempo", ["tempo", "card"])).toBe("card");
+    expect(resolveConfirmationMethod(undefined, "card", ["tempo", "card"])).toBe("card");
+    expect(resolveConfirmationMethod(undefined, undefined, ["card", "tempo"])).toBe("card");
+  });
+
+  it("includes pay_with in run confirmation commands when present", () => {
+    expect(formatRunConfirmationCommand("agent_123", "card")).toContain('pay_with: "card"');
+    expect(formatRunConfirmationCommand("agent_123", undefined)).not.toContain("pay_with");
+  });
+
+  it("includes pay_with in solve confirmation commands when present", () => {
+    expect(formatSolveConfirmationCommand("translate", 1, "card")).toContain('pay_with: "card"');
+    expect(formatSolveConfirmationCommand("translate", 1, undefined)).not.toContain("pay_with");
+  });
+
+  it("uses a stable solve pending key for the same request", () => {
+    const input = { text: "hello", target_language: "es" };
+    expect(makeSolvePendingKey("translate", input, 1)).toBe(
+      makeSolvePendingKey("translate", input, 1),
+    );
+  });
+
+  it("formats a payment choice prompt with explicit options", () => {
+    const prompt = formatPaymentChoicePrompt("Echo Agent", ["card", "tempo"], [
+      '  run_agent({ agent_id: "agent_123", input: <same>, pay_with: "card" })',
+      '  run_agent({ agent_id: "agent_123", input: <same>, pay_with: "tempo" })',
+    ]);
+
+    expect(prompt).toContain("Multiple payment methods are available for Echo Agent.");
+    expect(prompt).toContain('Available methods: "card", "tempo"');
+    expect(prompt).toContain('pay_with: "card"');
+  });
+});

package/src/tools/_payment-confirmation.ts

@@ -0,0 +1,52 @@
+export function resolveConfirmationMethod(
+  requestedMethod: string | undefined,
+  pendingMethod: string | undefined,
+  compatibleMethods: string[],
+): string | undefined {
+  return requestedMethod ?? pendingMethod ?? compatibleMethods[0];
+}
+
+export function formatPaymentLabel(method: string | undefined): string {
+  return method ?? "auto";
+}
+
+export function formatRunConfirmationCommand(
+  agentId: string,
+  method: string | undefined,
+): string {
+  const payWith = method ? `, pay_with: "${method}"` : "";
+  return `  run_agent({ agent_id: "${agentId}", input: <same>${payWith}, confirmed: true })`;
+}
+
+export function formatSolveConfirmationCommand(
+  intent: string,
+  budget: number,
+  method: string | undefined,
+): string {
+  const payWith = method ? `, pay_with: "${method}"` : "";
+  return `  solve({ intent: "${intent}", input: <same>, budget: ${budget}${payWith}, confirmed: true })`;
+}
+
+export function makeSolvePendingKey(
+  intent: string,
+  input: Record<string, unknown>,
+  budget: number,
+): string {
+  return JSON.stringify({ intent, input, budget });
+}
+
+export function formatPaymentChoicePrompt(
+  subject: string,
+  methods: string[],
+  commands: string[],
+): string {
+  return [
+    `Multiple payment methods are available for ${subject}.`,
+    "",
+    "Ask the user which payment method they want to use, then call one of:",
+    ...commands,
+    "",
+    `Available methods: ${methods.map((method) => `"${method}"`).join(", ")}`,
+    "For fully agentic execution, include pay_with explicitly.",
+  ].join("\n");
+}

package/src/tools/agent-info.ts

@@ -21,6 +21,15 @@ export function registerAgentInfoTools(server: McpServer): void {
       const s = (a.stats ?? {}) as Record<string, unknown>;
       const payment = (a.payment ?? {}) as Record<string, unknown>;
       const _pricing = (payment.pricing ?? {}) as Record<string, unknown>;
+      const creditPacks = payment.credit_packs as {
+        unit_type?: string;
+        packs?: Array<{
+          key?: string;
+          name?: string;
+          included_units?: number;
+          price_usd?: string;
+        }>;
+      } | null | undefined;
 
       const lines = [
         `${a.name}`,
@@ -28,7 +37,7 @@ export function registerAgentInfoTools(server: McpServer): void {
         "",
         (a.description as string) ?? "",
         "",
-        `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 as number) != null ? a.avgResponseTimeMs + "ms" : "N/A"}`,
         ...(() => {
@@ -41,6 +50,20 @@ export function registerAgentInfoTools(server: McpServer): void {
           const hint = outputTypeHint(a.tags as string[]);
           return hint ? [`Output: ${hint}`] : [];
         })(),
+        ...(() => {
+          if (!creditPacks?.packs?.length) return [];
+          const packLines = [
+            "",
+            `Discounted credit packs: ${creditPacks.unit_type ?? "run"}s`,
+          ];
+          for (const pack of creditPacks.packs) {
+            packLines.push(
+              `  ${pack.name ?? pack.key}: ${pack.included_units ?? 0} units for $${pack.price_usd ?? "0.00"}`,
+            );
+          }
+          packLines.push("  Use buy_agent_credit_pack to purchase one.");
+          return packLines;
+        })(),
       ];
 
       // Feedback summary (rating + tips)
@@ -107,7 +130,7 @@ export function registerAgentInfoTools(server: McpServer): void {
         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/src/tools/favorites.ts

@@ -54,10 +54,7 @@ export function registerFavoriteTools(server: McpServer) {
           const agent = await apiGet<Record<string, unknown>>(`/agents/${id}`);
           const rating = stars(agent.avgRating as number | null | undefined);
           const jobs = compactNumber(agent.totalExecutions as number | null | undefined);
-          const price = formatPrice(
-            agent.pricePer1kTokens as string | null | undefined,
-            agent.pricingModel as string | null | undefined,
-          );
+          const price = formatPrice(agent.pricePerRunUsd as string | null | undefined);
           lines.push(`${agent.name} ${rating} ${jobs} jobs | ${price}`);
           lines.push(`  ID: ${id}`);
           if (agent.description) lines.push(`  ${agent.description}`);

package/src/tools/index.ts

@@ -7,3 +7,4 @@ export { registerRateTools } from "./rate.js";
 export { registerWalletTools } from "./wallet.js";
 export { registerFavoriteTools } from "./favorites.js";
 export { registerTipTools } from "./tip.js";
+export { registerPassTools } from "./passes.js";

package/src/tools/observability.ts

@@ -0,0 +1,43 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { apiPost } from "../core/api-client.js";
+
+function text(t: string) {
+  return { content: [{ type: "text" as const, text: t }] };
+}
+
+export function registerObservabilityTools(server: McpServer): void {
+  server.tool(
+    "open_observability_dashboard",
+    "Generate a secure one-click sign-in URL for the Agent Wonderland web observability dashboard. The dashboard shows your agent runs, spend, rebates, and recent activity.",
+    {},
+    async () => {
+      const result = await apiPost<{
+        url: string;
+        expires_at: string;
+        consumer_principal?: string;
+      }>(
+        "/observability/link",
+        {},
+        { ensureConsumerPrincipal: true },
+      );
+
+      const lines = [
+        "Your secure observability link is ready:",
+        result.url,
+        "",
+        `Expires: ${result.expires_at}`,
+      ];
+
+      if (result.consumer_principal) {
+        lines.push(`Consumer principal: ${result.consumer_principal}`);
+      }
+
+      lines.push(
+        "",
+        "Open the link in your browser to view usage metrics, spend, rebates, and recent runs.",
+      );
+
+      return text(lines.join("\n"));
+    },
+  );
+}

package/src/tools/passes.ts

@@ -0,0 +1,228 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { apiGet, apiPostWithPayment } from "../core/api-client.js";
+import {
+  formatCreditPack,
+  formatCreditPackOffer,
+  getCreditPackProgram,
+} from "../core/passes.js";
+import {
+  getCompatiblePaymentMethods,
+  getConfiguredMethods,
+  hasWalletConfigured,
+  normalizePaymentMethod,
+} from "../core/payments.js";
+import { requiresSpendConfirmation } from "../core/config.js";
+import { ensureConsumerPrincipal } from "../core/principal.js";
+import { getOrCreatePendingCardSetup, formatCardSetupBlocks } from "../core/card-setup.js";
+import {
+  formatPaymentChoicePrompt,
+  formatPaymentLabel,
+  resolveConfirmationMethod,
+} from "./_payment-confirmation.js";
+import type { AgentRecord } from "../core/types.js";
+import type { CreditPackInventory, CreditPackOffer, CreditPackRecord } from "../core/passes.js";
+
+const pendingCreditPackPurchases = new Map<string, {
+  agentId: string;
+  agentName: string;
+  offer: CreditPackOffer;
+  method?: string;
+}>();
+
+function text(t: string) {
+  return { content: [{ type: "text" as const, text: t }] };
+}
+
+function multiText(...blocks: string[]) {
+  return { content: blocks.map((t) => ({ type: "text" as const, text: t })) };
+}
+
+async function getAgent(agentId: string): Promise<AgentRecord> {
+  return apiGet<AgentRecord>(`/agents/${agentId}`);
+}
+
+function findOffer(agent: AgentRecord, packId: string): CreditPackOffer | null {
+  const program = getCreditPackProgram(agent);
+  const pack = program?.packs?.find((candidate) => candidate.key === packId);
+  if (!pack) return null;
+
+  const price = Number(pack.price_usd ?? "0");
+  const units = pack.included_units ?? 0;
+  return {
+    pack_id: packId,
+    label: pack.name ?? pack.key ?? "Credit Pack",
+    included_units: units,
+    price_usd: price.toFixed(2),
+    effective_price_per_unit_usd: units > 0 ? (price / units).toFixed(6) : undefined,
+  };
+}
+
+export function registerPassTools(server: McpServer): void {
+  server.tool(
+    "buy_agent_credit_pack",
+    "Purchase a discounted prepaid credit pack for an agent. Credit packs are agent-specific and automatically cover future runs until the included units run out.",
+    {
+      agent_id: z.string().describe("Agent ID (UUID, slug, or name)"),
+      pack_id: z.string().optional().describe("Specific pack key to buy, like 'starter' or 'growth'. If omitted and only one pack exists, it is selected automatically."),
+      pay_with: z.string().optional().describe("Payment method — wallet ID, chain name, or 'card'. Auto-detected if omitted."),
+      confirmed: z.boolean().optional().describe("Set to true to confirm the purchase after seeing the quote."),
+    },
+    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\" })",
+          );
+        }
+      }
+
+      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 ?? ""))
+        .filter((offer): offer is CreditPackOffer => !!offer);
+
+      if (offers.length === 0) {
+        return text(`${agentName} does not currently offer discounted credit packs.`);
+      }
+
+      const configuredMethods = getConfiguredMethods();
+      const compatibleMethods = getCompatiblePaymentMethods(agent, configuredMethods);
+      const pending = pendingCreditPackPurchases.get(agent.id);
+      const requestedMethod = pay_with ?? pending?.method;
+      const normalizedRequestedMethod = requestedMethod ? normalizePaymentMethod(requestedMethod) : null;
+
+      if (requestedMethod && !normalizedRequestedMethod) {
+        return text(
+          `Payment method "${requestedMethod}" is not configured.\n\n` +
+          "Use wallet_status to review your current payment methods.",
+        );
+      }
+
+      if (normalizedRequestedMethod && !compatibleMethods.includes(normalizedRequestedMethod)) {
+        return text(
+          `This agent cannot be paid with "${requestedMethod}".\n\n` +
+          `Available payment methods for this agent: ${compatibleMethods.join(", ") || "none"}.`,
+        );
+      }
+
+      if (!requestedMethod && compatibleMethods.length === 0) {
+        return text(
+          `No compatible payment methods are configured for ${agentName}.\n\n` +
+          `Your configured methods: ${configuredMethods.join(", ") || "none"}`,
+        );
+      }
+
+      if (!requestedMethod && compatibleMethods.length > 1) {
+        return text(
+          formatPaymentChoicePrompt(
+            `${agentName} credit-pack purchase`,
+            compatibleMethods,
+            compatibleMethods.map((method) => `  buy_agent_credit_pack({ agent_id: "${agent.id}"${pack_id ? `, pack_id: "${pack_id}"` : ""}, pay_with: "${method}" })`),
+          ),
+        );
+      }
+
+      let resolvedOffer: CreditPackOffer;
+      if (pack_id) {
+        const offer = offers.find((candidate) => candidate.pack_id === pack_id);
+        if (!offer) {
+          return text(
+            `Unknown credit pack "${pack_id}" for ${agentName}.\n\n` +
+            `Available packs:\n${offers.map((offer) => `  ${formatCreditPackOffer(offer)}`).join("\n")}`,
+          );
+        }
+        resolvedOffer = offer;
+      } else if (offers.length === 1) {
+        resolvedOffer = offers[0]!;
+      } else {
+        return text([
+          `Multiple credit packs are available for ${agentName}.`,
+          "",
+          ...offers.map((offer) => `  ${offer.pack_id}: ${formatCreditPackOffer(offer)}`),
+          "",
+          "Choose one by calling:",
+          `  buy_agent_credit_pack({ agent_id: "${agent.id}", pack_id: "${offers[0]!.pack_id}" })`,
+        ].join("\n"));
+      }
+
+      const method = resolveConfirmationMethod(pay_with, pending?.method, compatibleMethods);
+      if (requiresSpendConfirmation() && !confirmed) {
+        pendingCreditPackPurchases.set(agent.id, {
+          agentId: agent.id,
+          agentName,
+          offer: resolvedOffer,
+          method,
+        });
+
+        return text([
+          `Ready to buy a credit pack for ${agentName}`,
+          "",
+          formatCreditPackOffer(resolvedOffer),
+          `Payment: ${formatPaymentLabel(method)}`,
+          `Consumer principal: ${principal}`,
+          "",
+          "To proceed, call:",
+          `  buy_agent_credit_pack({ agent_id: "${agent.id}", pack_id: "${resolvedOffer.pack_id}", pay_with: "${method}", confirmed: true })`,
+          "",
+          "To cancel, do nothing.",
+        ].join("\n"));
+      }
+
+      const result = await apiPostWithPayment<{
+        consumer_principal: string;
+        offer: CreditPackOffer;
+        credit_pack: CreditPackRecord;
+      }>(`/agents/${agent.id}/credit-packs/purchase`, { pack_id: resolvedOffer.pack_id }, method, { ensureConsumerPrincipal: true });
+
+      pendingCreditPackPurchases.delete(agent.id);
+
+      return text([
+        `Credit pack purchased for ${agentName}`,
+        "",
+        formatCreditPackOffer(result.offer),
+        formatCreditPack(result.credit_pack),
+        `Consumer principal: ${result.consumer_principal}`,
+        "",
+        "Future runs through run_agent will automatically use this credit pack while units remain.",
+      ].join("\n"));
+    },
+  );
+
+  server.tool(
+    "list_agent_credit_packs",
+    "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)"),
+    },
+    async ({ agent_id }) => {
+      const agent = await getAgent(agent_id);
+      const result = await apiGet<CreditPackInventory>(`/agents/${agent.id}/credit-packs`, { ensureConsumerPrincipal: true });
+
+      const lines = [
+        `Credit packs for ${agent.name}`,
+        ...(result.consumer_principal ? [`Consumer principal: ${result.consumer_principal}`] : []),
+      ];
+
+      if (result.offers.length > 0) {
+        lines.push("", "Available packs:", ...result.offers.map((offer) => `  ${offer.pack_id}: ${formatCreditPackOffer(offer)}`));
+      }
+
+      if (result.balances.length > 0) {
+        lines.push("", "Your balances:", ...result.balances.map((pack) => `  ${formatCreditPack(pack)}`));
+      } else {
+        lines.push("", "No purchased credit packs found for this agent.");
+      }
+
+      return text(lines.join("\n"));
+    },
+  );
+}