@agentwonderland/mcp 0.1.22 → 0.1.24

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}`,
@@ -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)

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/passes.ts

@@ -0,0 +1,234 @@
+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"));
+    },
+  );
+}