@agentwonderland/mcp 0.1.24 → 0.1.26

package/src/tools/solve.ts

@@ -13,11 +13,11 @@ import {
 } from "../core/payments.js";
 import { requiresSpendConfirmation, getDefaultTipAmount } from "../core/config.js";
 import { agentList, formatRunResult } from "../core/formatters.js";
+import { canSpend, recordSpend, requiresPolicyConfirmation } from "../core/spend-policy.js";
 import { uploadLocalFiles } from "../core/file-upload.js";
 import type { AgentRecord } from "../core/types.js";
 import { storeFeedbackToken } from "./_token-cache.js";
 import {
-  formatPaymentChoicePrompt,
   formatPaymentLabel,
   formatSolveConfirmationCommand,
   makeSolvePendingKey,
@@ -30,9 +30,10 @@ const POLL_MAX_MS = 120000;
 
 async function pollSolveJob(
   jobId: string,
+  paymentMethod?: string,
 ): Promise<{ status: string; output?: unknown; error_code?: string }> {
   const deadline = Date.now() + POLL_MAX_MS;
-  const walletAddress = await getWalletAddress();
+  const walletAddress = await getWalletAddress(paymentMethod);
   const walletParam = walletAddress ? `?wallet=${walletAddress}` : "";
 
   while (Date.now() < deadline) {
@@ -137,6 +138,8 @@ export function registerSolveTools(server: McpServer): void {
         .describe("Maximum budget in USD"),
       pay_with: z
         .string()
+        .trim()
+        .min(1)
         .optional()
         .describe("Payment method — wallet ID, chain name (tempo, base, etc.), or 'card'. Auto-detected if omitted."),
       confirmed: z
@@ -199,11 +202,13 @@ export function registerSolveTools(server: McpServer): void {
         const tipMsg = result.feedback_token ? await autoTip(jobId, agentId, agentName, result.feedback_token as string) : "";
         return multiText(formatRunResult(result), feedbackAsk(jobId, agentId, usedCreditPack ? undefined : cost, tipMsg));
       } catch (err: unknown) {
-        const isAuthError =
+        const status =
           err instanceof Error &&
-          "status" in err &&
-          (err as { status: number }).status === 401;
-        if (!isAuthError || !hasWalletConfigured()) throw err;
+          "status" in err
+            ? (err as { status: number }).status
+            : undefined;
+        const isRecoverableDirectSolveError = status === 401 || status === 402;
+        if (!isRecoverableDirectSolveError || !hasWalletConfigured()) throw err;
       }
 
       const params = new URLSearchParams({ q: intent, limit: "5" });
@@ -220,17 +225,15 @@ export function registerSolveTools(server: McpServer): void {
       }
 
       const discovery = agentList(agents, intent);
-      const inputTokens = Math.ceil(JSON.stringify(input).length / 4);
       const affordable = agents.filter((agent) => {
-        const price = parseFloat(agent.pricePer1kTokens ?? "0.01");
-        const cost = agent.pricingModel === "fixed" ? price : (inputTokens / 1000) * price;
-        return cost <= budget;
+        const price = parseFloat(agent.pricePerRunUsd ?? "0.01");
+        return price <= budget;
       });
       const selected = affordable[0] ?? agents[0];
-      const activeCreditPack = await getCreditPackInventory(selected.id).then(getActiveCreditPack);
+      const activeCreditPack = await getCreditPackInventory(selected.id, requestedMethod).then(getActiveCreditPack);
       const compatibleMethods = getCompatiblePaymentMethods(selected, configuredMethods);
 
-      if (!activeCreditPack && normalizedRequestedMethod && !compatibleMethods.includes(normalizedRequestedMethod)) {
+      if (normalizedRequestedMethod && !compatibleMethods.includes(normalizedRequestedMethod)) {
         return text(
           `The best matching agent cannot be paid with "${requestedMethod}".\n\n` +
           `Available payment methods for ${selected.name}: ${compatibleMethods.join(", ") || "none"}.\n` +
@@ -238,39 +241,21 @@ export function registerSolveTools(server: McpServer): void {
         );
       }
 
-      if (!activeCreditPack && !requestedMethod && compatibleMethods.length === 0) {
+      if (!activeCreditPack && compatibleMethods.length === 0) {
         return text(
           `No compatible payment methods are configured for ${selected.name}.\n\n` +
-          `Your configured methods: ${configuredMethods.join(", ") || "none"}\n` +
-          `Agent accepts: ${selected.payment?.accepted_payments?.join(", ") || "unknown"}\n` +
-          "Use wallet_status to review your current setup.",
+          "Use wallet_status to review your current payment methods.",
         );
       }
 
-      if (!activeCreditPack && !requestedMethod && compatibleMethods.length > 1) {
-        return text([
-          discovery,
-          "",
-          formatPaymentChoicePrompt(
-            selected.name ?? selected.id,
-            compatibleMethods,
-            compatibleMethods.map((method) =>
-              formatSolveConfirmationCommand(intent, budget, method).replace(", confirmed: true", ""),
-            ),
-          ),
-        ].join("\n"));
-      }
-
-      const method = activeCreditPack
-        ? undefined
-        : resolveConfirmationMethod(pay_with, pending?.method, compatibleMethods);
+      const method = resolveConfirmationMethod(requestedMethod, pending?.method, compatibleMethods);
+      const spendCheckMethod = method ?? normalizedRequestedMethod ?? compatibleMethods[0];
 
-      const selectedPrice = parseFloat(selected.pricePer1kTokens ?? "0.01");
-      const estimatedCost = selected.pricingModel === "fixed"
-        ? selectedPrice
-        : (inputTokens / 1000) * selectedPrice;
+      const selectedPrice = parseFloat(selected.pricePerRunUsd ?? "0.01");
+      const estimatedCost = selectedPrice;
 
-      if (!activeCreditPack && requiresSpendConfirmation() && !confirmed) {
+      const needsPolicyConfirmation = !activeCreditPack && requiresPolicyConfirmation(spendCheckMethod, estimatedCost);
+      if (!activeCreditPack && (requiresSpendConfirmation() || needsPolicyConfirmation) && !confirmed) {
         pendingSolves.set(pendingKey, { method });
         return text([
           discovery,
@@ -291,26 +276,47 @@ export function registerSolveTools(server: McpServer): void {
       }
 
       let result: Record<string, unknown>;
+      if (!activeCreditPack) {
+        const spendCheck = canSpend({
+          method: spendCheckMethod,
+          amountUsd: estimatedCost,
+        });
+        if (!spendCheck.ok) {
+          return text(spendCheck.message);
+        }
+      }
+
       try {
-        result = activeCreditPack
-          ? await apiPost<Record<string, unknown>>(
-            `/agents/${selected.id}/run`,
-            { input: processedInput },
-            { ensureConsumerPrincipal: true },
-          )
-          : await apiPostWithPayment<Record<string, unknown>>(
+        let usedPaidMethod = !activeCreditPack;
+        if (activeCreditPack) {
+          try {
+            result = await apiPost<Record<string, unknown>>(
+              `/agents/${selected.id}/run`,
+              { input: processedInput },
+              { ensureConsumerPrincipal: true },
+            );
+          } catch (packErr) {
+            const packApiErr = packErr as { status?: number };
+            if (packApiErr?.status !== 402) throw packErr;
+            result = await apiPostWithPayment<Record<string, unknown>>(
+              `/agents/${selected.id}/run`,
+              { input: processedInput },
+              method,
+            );
+            usedPaidMethod = true;
+          }
+        } else {
+          result = await apiPostWithPayment<Record<string, unknown>>(
             `/agents/${selected.id}/run`,
             { input: processedInput },
             method,
           );
+        }
+        if (usedPaidMethod) {
+          recordSpend(spendCheckMethod, estimatedCost);
+        }
       } catch (err: unknown) {
         const apiErr = err as { status?: number; message?: string };
-        if (activeCreditPack && apiErr?.status === 402) {
-          return text(
-            `Your available credit packs for ${selected.name} could not cover this run.\n\n` +
-            "Use list_agent_credit_packs to inspect your balances, or retry with a payment method.",
-          );
-        }
         if (apiErr?.status === 402) {
           return text(
             [
@@ -339,7 +345,7 @@ export function registerSolveTools(server: McpServer): void {
       }
 
       if (status === "processing") {
-        const pollResult = await pollSolveJob(jobId);
+        const pollResult = await pollSolveJob(jobId, method);
         if (pollResult.status === "completed") {
           const asyncFormatted = formatRunResult({
             ...result,

package/src/tools/wallet.ts

@@ -6,8 +6,12 @@ import {
   setCardConfig,
   addWallet,
   getPendingCardSetupToken,
+  getSpendPolicy,
+  setSpendPolicy,
 } from "../core/config.js";
-import { getWalletAddress } from "../core/payments.js";
+import { getWalletAddress, isCardPaymentEnabled } from "../core/payments.js";
+import { fetchUsdcBalance } from "../core/balances.js";
+import { getSettings } from "../core/settings.js";
 import {
   getOrCreatePendingCardSetup,
   formatCardSetupBlocks,
@@ -45,25 +49,36 @@ export function registerWalletTools(server: McpServer): void {
         );
       }
 
-      const lines = ["Payment methods:"];
+      const settings = await getSettings();
+      const networkLabel = settings ? ` (${settings.network})` : "";
+      const lines = [`Payment methods${networkLabel}:`];
 
       for (const w of wallets) {
         const label = w.label ? ` (${w.label})` : "";
         const storage =
           w.keyType === "ows" ? " [encrypted]" : " [plaintext]";
-        const chainAddresses = await Promise.all(
+        const chainLines = await Promise.all(
           w.chains.map(async (chainName) => {
             const addr = await getWalletAddress(chainName);
-            return `${chainName}: ${addr ?? "unknown"}`;
+            if (!addr) return `${chainName}: unknown`;
+            let balanceStr = "";
+            if (chainName === "tempo" || chainName === "base" || chainName === "solana") {
+              const balance = await fetchUsdcBalance(chainName, addr);
+              if (balance !== null) {
+                const num = Number(balance);
+                balanceStr = `   ${Number.isFinite(num) ? num.toFixed(4).replace(/\.?0+$/, "") : balance} USDC`;
+              }
+            }
+            return `${chainName}: ${addr}${balanceStr}`;
           }),
         );
-        lines.push(
-          `  ${w.id}${label}${storage}: ${chainAddresses.join(" | ")}`,
-        );
+        lines.push(`  ${w.id}${label}${storage}:`);
+        for (const line of chainLines) lines.push(`    ${line}`);
       }
 
-      if (card) {
-        lines.push(`  Card: ${card.brand} ****${card.last4}`);
+      if (card && isCardPaymentEnabled()) {
+        const stripeMode = settings?.stripe.mode === "test" ? " [Stripe test mode]" : "";
+        lines.push(`  Card: ${card.brand} ****${card.last4}${stripeMode}`);
         const capabilities = await getCardCapabilities();
         if (capabilities.spt_status === "enabled") {
           lines.push("  Card MPP: ready");
@@ -89,7 +104,7 @@ export function registerWalletTools(server: McpServer): void {
   // ── wallet_setup (NEW) ──────────────────────────────────────────
   server.tool(
     "wallet_setup",
-    "Set up or manage payment methods. Options: 'add-card' to connect a credit/debit card (recommended), 'remove-card' to disconnect a card, 'create' a crypto wallet, or 'import' an existing key. For crypto wallet changes (removal, key rotation), direct users to edit their config files manually — never handle private keys programmatically.",
+    "Set up or manage payment methods. Options: 'add-card' to connect a credit/debit card, 'remove-card' to disconnect a card, 'create' a crypto wallet, or 'import' an existing key. After card setup, use wallet_status to confirm whether card-backed MPP is ready. For crypto wallet changes (removal, key rotation), direct users to edit their config files manually — never handle private keys programmatically.",
     {
       action: z
         .enum(["create", "import", "add-card", "remove-card"])
@@ -110,6 +125,9 @@ export function registerWalletTools(server: McpServer): void {
     async ({ action, name, key, chain }) => {
       // ── Card setup flow ──────────────────────────────────────
       if (action === "add-card") {
+        if (!isCardPaymentEnabled()) {
+          return text("Card payments are temporarily unavailable. Use wallet_setup({ action: \"create\" }) for a crypto wallet instead.");
+        }
         const existing = getCardConfig();
         if (existing) {
           return text(`Card already connected: ${existing.brand} ****${existing.last4}\n\nTo replace it, remove the current card first.`);
@@ -339,9 +357,9 @@ export function registerWalletTools(server: McpServer): void {
   // ── wallet_set_policy (NEW) ─────────────────────────────────────
   server.tool(
     "wallet_set_policy",
-    "Set spending limits on a wallet to control agent costs. Limits reset daily.",
+    "Set client-side spending limits on a wallet to control agent costs in this MCP client. Limits reset daily.",
     {
-      wallet_id: z.string().describe("Wallet ID to set policy on"),
+      wallet_id: z.string().describe("Wallet ID to set local policy on"),
       max_per_tx: z
         .number()
         .positive()
@@ -352,8 +370,13 @@ export function registerWalletTools(server: McpServer): void {
         .positive()
         .optional()
         .describe("Maximum USD per day across all transactions"),
+      require_confirmation_above: z
+        .number()
+        .positive()
+        .optional()
+        .describe("Require manual confirmation above this USD amount even when auto-spend is enabled"),
     },
-    async ({ wallet_id, max_per_tx, max_per_day }) => {
+    async ({ wallet_id, max_per_tx, max_per_day, require_confirmation_above }) => {
       const wallets = getWallets();
       const wallet = wallets.find((w) => w.id === wallet_id);
 
@@ -364,29 +387,42 @@ export function registerWalletTools(server: McpServer): void {
         );
       }
 
-      if (max_per_tx == null && max_per_day == null) {
+      if (
+        max_per_tx == null &&
+        max_per_day == null &&
+        require_confirmation_above == null
+      ) {
         return text(
-          "No policy changes specified. Provide max_per_tx and/or max_per_day.",
+          "No policy changes specified. Provide at least one policy field.",
         );
       }
 
+      const existing = getSpendPolicy(wallet_id) ?? {};
+      const nextPolicy = {
+        ...existing,
+        ...(max_per_tx != null ? { maxPerTxUsd: max_per_tx } : {}),
+        ...(max_per_day != null ? { maxPerDayUsd: max_per_day } : {}),
+        ...(require_confirmation_above != null ? { requireConfirmationAboveUsd: require_confirmation_above } : {}),
+      };
+      setSpendPolicy(wallet_id, nextPolicy);
+
       // Build policy summary
       const policies: string[] = [];
-      if (max_per_tx != null) {
-        policies.push(`Max per transaction: $${max_per_tx.toFixed(2)}`);
+      if (nextPolicy.maxPerTxUsd != null) {
+        policies.push(`Max per transaction: $${nextPolicy.maxPerTxUsd.toFixed(2)}`);
       }
-      if (max_per_day != null) {
-        policies.push(`Max per day: $${max_per_day.toFixed(2)}`);
+      if (nextPolicy.maxPerDayUsd != null) {
+        policies.push(`Max per day: $${nextPolicy.maxPerDayUsd.toFixed(2)}`);
+      }
+      if (nextPolicy.requireConfirmationAboveUsd != null) {
+        policies.push(`Require confirmation above: $${nextPolicy.requireConfirmationAboveUsd.toFixed(2)}`);
       }
-
-      // Note: actual persistence depends on the config module supporting policy fields.
-      // For now, we report what would be set. The core/config module will handle storage.
       return text(
         [
-          `Spending policy set for wallet "${wallet_id}":`,
+          `Local spending policy set for wallet "${wallet_id}":`,
           ...policies.map((p) => `  ${p}`),
           "",
-          "Policy will be enforced on all future transactions from this wallet.",
+          "Policy is stored in this MCP client's local config and enforced on future transactions from this wallet on this client.",
         ].join("\n"),
       );
     },