@agentwonderland/mcp 0.1.24 → 0.1.26

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

@@ -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/jobs.ts

@@ -18,7 +18,16 @@ 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}`);
+      let url = `/jobs/${job_id}`;
+
+      if (!isAuthenticated() && hasWalletConfigured()) {
+        const address = await getWalletAddress();
+        if (address) {
+          url += `?wallet=${encodeURIComponent(address)}`;
+        }
+      }
+
+      const result = await apiGet<Record<string, unknown>>(url);
       if (result.status === "processing") {
         return text(`Job ${job_id} is still processing...`);
       }

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

@@ -4,6 +4,7 @@ import { apiGet, apiPostWithPayment } from "../core/api-client.js";
 import {
   formatCreditPack,
   formatCreditPackOffer,
+  getCreditPackInventory,
   getCreditPackProgram,
 } from "../core/passes.js";
 import {
@@ -13,7 +14,7 @@ import {
   normalizePaymentMethod,
 } 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,
@@ -84,7 +85,6 @@ export function registerPassTools(server: McpServer): void {
 
       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,7 +155,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,
@@ -182,12 +182,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);
 
@@ -198,7 +193,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"));
     },
   );
@@ -208,10 +204,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}`,

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,
@@ -32,9 +32,10 @@ const POLL_MAX_MS = 120000;
 
 async function pollJobUntilDone(
   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) {
@@ -100,7 +101,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).optional().describe("Payment method — wallet ID, chain name (tempo, base, etc.), or 'card'. Auto-detected if omitted."),
       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 +125,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 creditPackInventory = await getCreditPackInventory(agent.id, requestedMethod);
+      const activeCreditPack = getActiveCreditPack(creditPackInventory);
 
-      if (!activeCreditPack && requestedMethod && !normalizedRequestedMethod) {
+      if (requestedMethod && !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 (normalizedRequestedMethod && !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 +149,28 @@ export function registerRunTools(server: McpServer): void {
         );
       }
 
-      if (!activeCreditPack && !requestedMethod && compatibleMethods.length === 0) {
+      if (!activeCreditPack && 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.",
+          "Use wallet_status to review your current payment methods.",
         );
       }
 
-      if (!activeCreditPack && !requestedMethod && compatibleMethods.length > 1) {
-        return text(
-          formatPaymentChoicePrompt(
-            agentName,
-            compatibleMethods,
-            compatibleMethods.map((method) => formatRunConfirmationCommand(agent.id, method).replace(", confirmed: true", "")),
-          ),
-        );
-      }
+      const method = resolveConfirmationMethod(requestedMethod, pending?.method, compatibleMethods);
+      const spendCheckMethod = method ?? normalizedRequestedMethod ?? compatibleMethods[0];
 
-      const method = activeCreditPack
-        ? undefined
-        : resolveConfirmationMethod(pay_with, pending?.method, compatibleMethods);
+      if (!activeCreditPack) {
+        const spendCheck = canSpend({
+          method: spendCheckMethod,
+          amountUsd: price,
+        });
+        if (!spendCheck.ok) {
+          return text(spendCheck.message);
+        }
+      }
 
-      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 +216,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";
@@ -277,7 +286,7 @@ export function registerRunTools(server: McpServer): void {
       const usedCreditPack = result.consumption_mode === "credit_pack";
 
       if (status === "processing") {
-        const pollResult = await pollJobUntilDone(jobId);
+        const pollResult = await pollJobUntilDone(jobId, method);
         if (pollResult.status === "completed") {
           const asyncFormatted = formatRunResult({
             ...result,