@agentwonderland/mcp 0.1.24 → 0.1.25

package/src/core/formatters.ts

@@ -36,11 +36,10 @@ export function isFileOutput(output: unknown): output is { type: "file"; url: st
 
 // ── Price formatting ─────────────────────────────────────────────
 
-export function formatPrice(pricePer1kTokens?: string | null, pricingModel?: string | null): string {
-  if (!pricePer1kTokens) return "free";
-  const p = parseFloat(pricePer1kTokens);
-  if (pricingModel === "fixed") return `$${p.toFixed(2)}/req`;
-  return `$${p.toFixed(3)}/1k tokens`;
+export function formatPrice(pricePerRunUsd?: string | null): string {
+  if (!pricePerRunUsd) return "free";
+  const p = parseFloat(pricePerRunUsd);
+  return `$${p.toFixed(2)}/req`;
 }
 
 // ── Agent line (compact, one line per agent) ─────────────────────
@@ -52,8 +51,7 @@ interface AgentLike {
   avgRating?: number | null;
   ratingCount?: number;
   totalExecutions?: number;
-  pricePer1kTokens?: string;
-  pricingModel?: string;
+  pricePerRunUsd?: string;
   stats?: { completedJobs?: number; avgRating?: number | null };
   [key: string]: unknown;
 }
@@ -63,7 +61,7 @@ export function agentLine(agent: AgentLike): string {
   const slug = agent.slug ? ` (${agent.slug})` : "";
   const rating = agent.avgRating ?? agent.stats?.avgRating ?? null;
   const jobs = agent.stats?.completedJobs ?? agent.totalExecutions ?? 0;
-  const price = formatPrice(agent.pricePer1kTokens, agent.pricingModel);
+  const price = formatPrice(agent.pricePerRunUsd);
   const reliability = agent.successRate != null && Number(agent.successRate) < 1
     ? ` • ${(Number(agent.successRate) * 100).toFixed(0)}% reliable`
     : "";

package/src/core/payments.ts

@@ -63,7 +63,10 @@ function clearStaleCardCache(activeKey?: string): void {
 
 // ── Per-protocol initializers ───────────────────────────────────
 
-async function initMpp(wallet: WalletEntry): Promise<typeof fetch | null> {
+async function initEvmMppForChain(
+  wallet: WalletEntry,
+  chain: "tempo" | "base",
+): Promise<typeof fetch | null> {
   try {
     const { Mppx, tempo } = await import("mppx/client");
     let account;
@@ -78,8 +81,15 @@ async function initMpp(wallet: WalletEntry): Promise<typeof fetch | null> {
       return null;
     }
 
-    const { baseChargeClient } = await import("./base-charge.js");
-    const mppx = Mppx.create({ methods: [tempo({ account }), baseChargeClient({ account })] as any });
+    const methods = [];
+    if (chain === "tempo") {
+      methods.push(tempo({ account }));
+    } else {
+      const { baseChargeClient } = await import("./base-charge.js");
+      methods.push(baseChargeClient({ account }));
+    }
+
+    const mppx = Mppx.create({ methods: methods as any });
     return mppx.fetch.bind(mppx) as typeof fetch;
   } catch {
     return null;
@@ -150,7 +160,10 @@ async function initForChain(wallet: WalletEntry, chain: string): Promise<typeof
   if (chain === "solana") {
     return initSolanaMpp(wallet);
   }
-  return initMpp(wallet);
+  if (chain === "tempo" || chain === "base") {
+    return initEvmMppForChain(wallet, chain);
+  }
+  return null;
 }
 
 // ── Public API ──────────────────────────────────────────────────

package/src/core/solana-charge.ts

@@ -13,6 +13,7 @@ import {
   getAssociatedTokenAddressSync,
 } from "@solana/spl-token";
 import type { WalletEntry } from "./config.js";
+import { toAtomicAmount } from "./amount-utils.js";
 
 export const SOLANA_USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v" as const;
 export const SOLANA_CHAIN_ID = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp" as const;
@@ -98,7 +99,7 @@ export function solanaChargeClient(config: SolanaChargeClientConfig) {
   return Method.toClient(solanaChargeMethod as any, {
     async createCredential({ challenge }: any) {
       const { request } = challenge;
-      const amount = BigInt(request.amount);
+      const amount = toAtomicAmount(request.amount, request.decimals ?? 6);
       const decimals = request.decimals ?? 6;
       const mint = new PublicKey(request.currency ?? SOLANA_USDC_MINT);
       const recipient = new PublicKey(request.recipient);

package/src/core/spend-policy.ts

@@ -0,0 +1,69 @@
+import {
+  getSpendLedger,
+  getSpendPolicy,
+  saveSpendLedger,
+  type SpendLedgerEntry,
+} from "./config.js";
+
+const LEDGER_RETENTION_DAYS = 35;
+
+function utcDay(now: Date): string {
+  return now.toISOString().slice(0, 10);
+}
+
+function pruneLedger(entries: SpendLedgerEntry[], now: Date): SpendLedgerEntry[] {
+  const cutoff = new Date(now);
+  cutoff.setUTCDate(cutoff.getUTCDate() - LEDGER_RETENTION_DAYS);
+  return entries.filter((entry) => new Date(entry.timestamp) >= cutoff);
+}
+
+export function getDailySpend(method: string, now = new Date()): number {
+  const day = utcDay(now);
+  return getSpendLedger()
+    .filter((entry) => entry.method === method && entry.day === day)
+    .reduce((sum, entry) => sum + entry.amountUsd, 0);
+}
+
+export function canSpend(params: {
+  method: string;
+  amountUsd: number;
+}): { ok: true } | { ok: false; message: string } {
+  const policy = getSpendPolicy(params.method);
+  if (!policy) return { ok: true };
+
+  if (policy.maxPerTxUsd != null && params.amountUsd > policy.maxPerTxUsd) {
+    return {
+      ok: false,
+      message: `Transaction blocked by spend policy: $${params.amountUsd.toFixed(2)} exceeds max_per_tx of $${policy.maxPerTxUsd.toFixed(2)} for "${params.method}".`,
+    };
+  }
+
+  if (policy.maxPerDayUsd != null) {
+    const spentToday = getDailySpend(params.method);
+    if (spentToday + params.amountUsd > policy.maxPerDayUsd) {
+      return {
+        ok: false,
+        message: `Transaction blocked by spend policy: daily spend would be $${(spentToday + params.amountUsd).toFixed(2)} > $${policy.maxPerDayUsd.toFixed(2)} for "${params.method}".`,
+      };
+    }
+  }
+
+  return { ok: true };
+}
+
+export function requiresPolicyConfirmation(method: string, amountUsd: number): boolean {
+  const policy = getSpendPolicy(method);
+  if (!policy?.requireConfirmationAboveUsd) return false;
+  return amountUsd >= policy.requireConfirmationAboveUsd;
+}
+
+export function recordSpend(method: string, amountUsd: number, now = new Date()): void {
+  const entries = pruneLedger(getSpendLedger(), now);
+  entries.push({
+    method,
+    amountUsd,
+    day: utcDay(now),
+    timestamp: now.toISOString(),
+  });
+  saveSpendLedger(entries);
+}

package/src/core/types.ts

@@ -6,8 +6,7 @@ export interface AgentRecord {
   id: string;
   name: string;
   description?: string;
-  pricePer1kTokens?: string;
-  pricingModel?: string;
+  pricePerRunUsd?: string;
   avgRating?: number | null;
   totalExecutions?: number;
   successRate?: number | string | null;

package/src/index.ts

@@ -14,6 +14,7 @@ import { registerWalletTools } from "./tools/wallet.js";
 import { registerFavoriteTools } from "./tools/favorites.js";
 import { registerTipTools } from "./tools/tip.js";
 import { registerPassTools } from "./tools/passes.js";
+import { registerObservabilityTools } from "./tools/observability.js";
 
 // ── Resources ────────────────────────────────────────────────────
 import { registerAgentResources } from "./resources/agents.js";
@@ -50,8 +51,9 @@ export async function startMcpServer(): Promise<void> {
         "- Crypto wallets (Tempo USDC, Base USDC, Solana USDC) are available for advanced users.",
         "- Card and crypto are SEPARATE payment methods. Card charges a credit card; crypto sends USDC on-chain.",
         "- Card is set as the default payment method when configured.",
-        "- If multiple valid payment methods are available for a run and pay_with is not specified, ask the user which one to use.",
-        "- For fully agentic execution, include pay_with explicitly.",
+        "- run_agent() and solve() require pay_with explicitly.",
+        "- Use wallet_status to see the exact payment methods the user has configured before calling a paid tool.",
+        "- Use open_observability_dashboard() to open a secure web usage dashboard for runs/spend/rebates.",
         "- Payment is automatic once configured. Users are never charged for failed runs.",
         "- Do NOT ask the user to set up payment before they try to run an agent. Let them explore freely.",
         "- If a specific payment method fails, report the error clearly. Do NOT silently fall back to a different method.",
@@ -79,6 +81,7 @@ export async function startMcpServer(): Promise<void> {
   registerFavoriteTools(server);
   registerTipTools(server);
   registerPassTools(server);
+  registerObservabilityTools(server);
 
   // Register resources
   registerAgentResources(server);

package/src/prompts/index.ts

@@ -18,7 +18,7 @@ export function registerPrompts(server: McpServer) {
             "1. Check my wallet status with wallet_status",
             "2. If no wallet is configured, help me create one with wallet_setup",
             "3. Show me some popular agents with search_agents",
-            "4. Briefly explain how solve, run_agent, buy_agent_credit_pack, rating, and tipping work",
+            "4. Briefly explain how solve, run_agent, buy_agent_credit_pack, pay_with selection, rating, and tipping work",
           ].join("\n"),
         },
       }],
@@ -86,7 +86,7 @@ export function registerPrompts(server: McpServer) {
           text: [
             `Complete this task on Agent Wonderland within $${budget || "1.00"}: "${task}"`,
             "",
-            "Use the solve tool with the budget parameter. Show me what agent was selected and why.",
+            "Use the solve tool with the budget parameter and an explicit pay_with method. Show me what agent was selected and why.",
           ].join("\n"),
         },
       }],
@@ -108,6 +108,8 @@ export function registerPrompts(server: McpServer) {
           text: [
             `Run agent ${agent_id} with this input: ${input}`,
             "",
+            "Include an explicit pay_with method when you call run_agent.",
+            "",
             "After getting the result:",
             "1. Summarize the output",
             "2. Assess the quality",

package/src/resources/agents.ts

@@ -9,7 +9,7 @@ export function registerAgentResources(server: McpServer) {
     const lines = agents.map(a => {
       const rating = stars(a.reputationScore);
       const jobs = compactNumber(a.totalExecutions);
-      const price = formatPrice(a.pricePer1kTokens);
+      const price = formatPrice(a.pricePerRunUsd);
       return `${a.name} ${rating} ${jobs} jobs | ${price}/req — ${a.description || ""}`;
     });
     return {

package/src/tools/agent-info.ts

@@ -37,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"}`,
         ...(() => {
@@ -130,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/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

@@ -155,7 +155,6 @@ export function registerPassTools(server: McpServer): void {
       }
 
       const method = resolveConfirmationMethod(pay_with, pending?.method, compatibleMethods);
-
       if (requiresSpendConfirmation() && !confirmed) {
         pendingCreditPackPurchases.set(agent.id, {
           agentId: agent.id,
@@ -182,12 +181,7 @@ export function registerPassTools(server: McpServer): void {
         consumer_principal: string;
         offer: CreditPackOffer;
         credit_pack: CreditPackRecord;
-      }>(
-        `/agents/${agent.id}/credit-packs/purchase`,
-        { pack_id: resolvedOffer.pack_id },
-        method,
-        { ensureConsumerPrincipal: true },
-      );
+      }>(`/agents/${agent.id}/credit-packs/purchase`, { pack_id: resolvedOffer.pack_id }, method, { ensureConsumerPrincipal: true });
 
       pendingCreditPackPurchases.delete(agent.id);
 

package/src/tools/run.ts

@@ -17,10 +17,10 @@ import {
 } from "../core/payments.js";
 import { requiresSpendConfirmation, getDefaultTipAmount } from "../core/config.js";
 import { formatRunResult } from "../core/formatters.js";
+import { canSpend, recordSpend, requiresPolicyConfirmation } from "../core/spend-policy.js";
 import { storeFeedbackToken } from "./_token-cache.js";
 import { getOrCreatePendingCardSetup, formatCardSetupBlocks } from "../core/card-setup.js";
 import {
-  formatPaymentChoicePrompt,
   formatPaymentLabel,
   formatRunConfirmationCommand,
   resolveConfirmationMethod,
@@ -100,7 +100,7 @@ export function registerRunTools(server: McpServer): void {
     {
       agent_id: z.string().describe("Agent ID (UUID, slug, or name)"),
       input: z.record(z.unknown()).describe("Input payload for the agent"),
-      pay_with: z.string().optional().describe("Payment method — wallet ID, chain name (tempo, base, etc.), or 'card'. Auto-detected if omitted."),
+      pay_with: z.string().trim().min(1).describe("Required payment method — wallet ID, chain name (tempo, base, etc.), or 'card'. Use wallet_status to see configured options."),
       confirmed: z.boolean().optional().describe("Set to true to confirm spending after seeing the price quote."),
     },
     async ({ agent_id, input, pay_with, confirmed }) => {
@@ -124,24 +124,23 @@ export function registerRunTools(server: McpServer): void {
         return text(`Agent "${agent_id}" not found. Use search_agents to find available agents.`);
       }
 
-      const price = parseFloat(agent.pricePer1kTokens ?? "0.01");
+      const price = parseFloat(agent.pricePerRunUsd ?? "0.01");
       const agentName = agent.name ?? agent_id;
       const creditPackInventory = await getCreditPackInventory(agent.id);
       const activeCreditPack = getActiveCreditPack(creditPackInventory);
-      const configuredMethods = getConfiguredMethods();
-      const compatibleMethods = getCompatiblePaymentMethods(agent, configuredMethods);
+      const compatibleMethods = getCompatiblePaymentMethods(agent, getConfiguredMethods());
       const pending = pendingRuns.get(agent.id);
-      const requestedMethod = pay_with ?? pending?.method;
-      const normalizedRequestedMethod = requestedMethod ? normalizePaymentMethod(requestedMethod) : null;
+      const requestedMethod = pay_with;
+      const normalizedRequestedMethod = normalizePaymentMethod(requestedMethod);
 
-      if (!activeCreditPack && requestedMethod && !normalizedRequestedMethod) {
+      if (!normalizedRequestedMethod) {
         return text(
           `Payment method "${requestedMethod}" is not configured.\n\n` +
           "Use wallet_status to review your current payment methods.",
         );
       }
 
-      if (!activeCreditPack && normalizedRequestedMethod && !compatibleMethods.includes(normalizedRequestedMethod)) {
+      if (!compatibleMethods.includes(normalizedRequestedMethod)) {
         return text(
           `This agent cannot be paid with "${requestedMethod}".\n\n` +
           `Available payment methods for this agent: ${compatibleMethods.join(", ") || "none"}.\n` +
@@ -149,30 +148,21 @@ export function registerRunTools(server: McpServer): void {
         );
       }
 
-      if (!activeCreditPack && !requestedMethod && compatibleMethods.length === 0) {
-        return text(
-          `No compatible payment methods are configured for ${agentName}.\n\n` +
-          `Your configured methods: ${configuredMethods.join(", ") || "none"}\n` +
-          `Agent accepts: ${agent.payment?.accepted_payments?.join(", ") || "unknown"}\n` +
-          "Use wallet_status to review your current setup.",
-        );
-      }
+      const method = resolveConfirmationMethod(pay_with, pending?.method, compatibleMethods);
+      const spendCheckMethod = method ?? normalizedRequestedMethod;
 
-      if (!activeCreditPack && !requestedMethod && compatibleMethods.length > 1) {
-        return text(
-          formatPaymentChoicePrompt(
-            agentName,
-            compatibleMethods,
-            compatibleMethods.map((method) => formatRunConfirmationCommand(agent.id, method).replace(", confirmed: true", "")),
-          ),
-        );
+      if (!activeCreditPack) {
+        const spendCheck = canSpend({
+          method: spendCheckMethod,
+          amountUsd: price,
+        });
+        if (!spendCheck.ok) {
+          return text(spendCheck.message);
+        }
       }
 
-      const method = activeCreditPack
-        ? undefined
-        : resolveConfirmationMethod(pay_with, pending?.method, compatibleMethods);
-
-      if (!activeCreditPack && requiresSpendConfirmation() && !confirmed) {
+      const needsPolicyConfirmation = !activeCreditPack && requiresPolicyConfirmation(spendCheckMethod, price);
+      if (!activeCreditPack && (requiresSpendConfirmation() || needsPolicyConfirmation) && !confirmed) {
         pendingRuns.set(agent.id, {
           agent: { id: agent.id, name: agentName, price },
           input,
@@ -218,26 +208,37 @@ export function registerRunTools(server: McpServer): void {
       }
 
       let result: Record<string, unknown>;
+      let usedPaidMethod = !activeCreditPack;
       try {
-        result = activeCreditPack
-          ? await apiPost<Record<string, unknown>>(
-            `/agents/${agent.id}/run`,
-            { input: processedInput },
-            { ensureConsumerPrincipal: true },
-          )
-          : await apiPostWithPayment<Record<string, unknown>>(
+        if (activeCreditPack) {
+          try {
+            result = await apiPost<Record<string, unknown>>(
+              `/agents/${agent.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/${agent.id}/run`,
+              { input: processedInput },
+              method,
+            );
+            usedPaidMethod = true;
+          }
+        } else {
+          result = await apiPostWithPayment<Record<string, unknown>>(
             `/agents/${agent.id}/run`,
             { input: processedInput },
             method,
           );
+        }
+        if (usedPaidMethod) {
+          recordSpend(spendCheckMethod, price);
+        }
       } catch (err: unknown) {
         const apiErr = err as { status?: number; message?: string };
-        if (activeCreditPack && apiErr?.status === 402) {
-          return text(
-            `Your available credit packs for ${agentName} 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) {
           const allMethods = getConfiguredMethods();
           const methodName = method ?? allMethods[0] ?? "auto";

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,
@@ -137,8 +137,9 @@ export function registerSolveTools(server: McpServer): void {
         .describe("Maximum budget in USD"),
       pay_with: z
         .string()
-        .optional()
-        .describe("Payment method — wallet ID, chain name (tempo, base, etc.), or 'card'. Auto-detected if omitted."),
+        .trim()
+        .min(1)
+        .describe("Required payment method — wallet ID, chain name (tempo, base, etc.), or 'card'. Use wallet_status to see configured options."),
       confirmed: z
         .boolean()
         .optional()
@@ -161,10 +162,10 @@ export function registerSolveTools(server: McpServer): void {
       const pendingKey = makeSolvePendingKey(intent, input, budget);
       const pending = pendingSolves.get(pendingKey);
       const configuredMethods = getConfiguredMethods();
-      const requestedMethod = pay_with ?? pending?.method;
-      const normalizedRequestedMethod = requestedMethod ? normalizePaymentMethod(requestedMethod) : null;
+      const requestedMethod = pay_with;
+      const normalizedRequestedMethod = normalizePaymentMethod(requestedMethod);
 
-      if (requestedMethod && !normalizedRequestedMethod) {
+      if (!normalizedRequestedMethod) {
         return text(
           `Payment method "${requestedMethod}" is not configured.\n\n` +
           "Use wallet_status to review your current payment methods.",
@@ -220,17 +221,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 compatibleMethods = getCompatiblePaymentMethods(selected, configuredMethods);
 
-      if (!activeCreditPack && normalizedRequestedMethod && !compatibleMethods.includes(normalizedRequestedMethod)) {
+      if (!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 +237,14 @@ export function registerSolveTools(server: McpServer): void {
         );
       }
 
-      if (!activeCreditPack && !requestedMethod && 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.",
-        );
-      }
-
-      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(pay_with, pending?.method, compatibleMethods);
+      const spendCheckMethod = method ?? normalizedRequestedMethod;
 
-      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 +265,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(
             [