@agentwonderland/mcp 0.1.25 → 0.1.26

package/src/core/solana-charge.ts

@@ -9,6 +9,7 @@ import { Connection, Keypair, PublicKey, Transaction, sendAndConfirmTransaction
 import {
   ASSOCIATED_TOKEN_PROGRAM_ID,
   TOKEN_PROGRAM_ID,
+  createAssociatedTokenAccountInstruction,
   createTransferCheckedInstruction,
   getAssociatedTokenAddressSync,
 } from "@solana/spl-token";
@@ -75,24 +76,40 @@ interface SolanaChargeClientConfig {
   rpcUrl?: string;
 }
 
-async function resolveRecipientTokenAccount(
+export async function resolveRecipientTokenAccount(
   connection: Connection,
   mint: PublicKey,
   recipient: PublicKey,
-): Promise<PublicKey> {
+): Promise<{ tokenAccount: PublicKey; needsCreateAssociatedAccount: boolean }> {
   const accountInfo = await connection.getParsedAccountInfo(recipient, "confirmed");
   const owner = accountInfo.value?.owner;
   if (owner && owner.toBase58() === TOKEN_PROGRAM_ID.toBase58()) {
-    return recipient;
+    return {
+      tokenAccount: recipient,
+      needsCreateAssociatedAccount: false,
+    };
   }
 
-  return getAssociatedTokenAddressSync(
+  const associatedTokenAccount = getAssociatedTokenAddressSync(
     mint,
     recipient,
     false,
     TOKEN_PROGRAM_ID,
     ASSOCIATED_TOKEN_PROGRAM_ID,
   );
+  const associatedAccountInfo = await connection.getParsedAccountInfo(associatedTokenAccount, "confirmed");
+  const associatedOwner = associatedAccountInfo.value?.owner;
+  if (associatedOwner && associatedOwner.toBase58() === TOKEN_PROGRAM_ID.toBase58()) {
+    return {
+      tokenAccount: associatedTokenAccount,
+      needsCreateAssociatedAccount: false,
+    };
+  }
+
+  return {
+    tokenAccount: associatedTokenAccount,
+    needsCreateAssociatedAccount: true,
+  };
 }
 
 export function solanaChargeClient(config: SolanaChargeClientConfig) {
@@ -114,27 +131,44 @@ export function solanaChargeClient(config: SolanaChargeClientConfig) {
         TOKEN_PROGRAM_ID,
         ASSOCIATED_TOKEN_PROGRAM_ID,
       );
-      const destinationTokenAccount = await resolveRecipientTokenAccount(
+      const destination = await resolveRecipientTokenAccount(
         connection,
         mint,
         recipient,
       );
+      const instructions = [];
+
+      if (destination.needsCreateAssociatedAccount) {
+        instructions.push(
+          createAssociatedTokenAccountInstruction(
+            owner,
+            destination.tokenAccount,
+            recipient,
+            mint,
+            TOKEN_PROGRAM_ID,
+            ASSOCIATED_TOKEN_PROGRAM_ID,
+          ),
+        );
+      }
 
-      const instruction = createTransferCheckedInstruction(
+      instructions.push(createTransferCheckedInstruction(
         sourceTokenAccount,
         mint,
-        destinationTokenAccount,
+        destination.tokenAccount,
         owner,
         amount,
         decimals,
-      );
+      ));
 
       const { blockhash } = await connection.getLatestBlockhash("confirmed");
 
       const transaction = new Transaction({
         feePayer: owner,
         recentBlockhash: blockhash,
-      }).add(instruction);
+      });
+      for (const instruction of instructions) {
+        transaction.add(instruction);
+      }
 
       const signature = await sendAndConfirmTransaction(connection, transaction, [keypair], {
         commitment: "confirmed",

package/src/core/tempo-charge.ts

@@ -0,0 +1,104 @@
+/**
+ * Custom MPP payment method: Tempo EVM USDC charge (client-side).
+ *
+ * Sends a standard ERC-20 transfer on Tempo and returns the tx hash as the
+ * payment credential.
+ */
+import { Method, Credential, z } from "mppx";
+import type { LocalAccount } from "viem/accounts";
+import { toAtomicAmount } from "./amount-utils.js";
+
+const TEMPO_USDC = "0x20c000000000000000000000b9537d11c60e8b50" as const;
+const PATH_USD = "0x20c0000000000000000000000000000000000000" as const;
+const TEMPO_MAINNET_CHAIN_ID = 4217;
+const TEMPO_TESTNET_CHAIN_ID = 42431;
+
+const ERC20_ABI = [
+  {
+    type: "function",
+    name: "transfer",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "value", type: "uint256" },
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+  },
+] as const;
+
+const tempoChargeMethod = Method.from({
+  name: "tempo" as const,
+  intent: "charge" as const,
+  schema: {
+    credential: {
+      payload: z.object({
+        hash: z.string(),
+        type: z.literal("hash"),
+      }),
+    },
+    request: z.pipe(
+      z.object({
+        amount: z.string(),
+        currency: z.string(),
+        recipient: z.string(),
+        chainId: z.optional(z.number()),
+        decimals: z.optional(z.number()),
+      }),
+      z.transform((v: any) => ({
+        ...v,
+        methodDetails: {
+          chainId: v.chainId ?? TEMPO_MAINNET_CHAIN_ID,
+        },
+      })),
+    ),
+  },
+});
+
+interface TempoChargeClientConfig {
+  account: LocalAccount;
+  rpcUrl?: string;
+}
+
+export function tempoChargeClient(config: TempoChargeClientConfig) {
+  return Method.toClient(tempoChargeMethod as any, {
+    async createCredential({ challenge }: any) {
+      const { request } = challenge;
+      const amount = toAtomicAmount(request.amount, request.decimals ?? 6);
+      const recipient = request.recipient as `0x${string}`;
+      const currency = (request.currency ?? TEMPO_USDC) as `0x${string}`;
+      const chainId = request.methodDetails?.chainId ?? request.chainId ?? TEMPO_MAINNET_CHAIN_ID;
+
+      const { createWalletClient, createPublicClient, http } = await import("viem");
+      const { tempo, tempoModerato } = await import("viem/chains");
+
+      const chain = chainId === TEMPO_TESTNET_CHAIN_ID ? tempoModerato : tempo;
+      const rpcUrl = config.rpcUrl ?? chain.rpcUrls.default.http[0];
+
+      const walletClient = createWalletClient({
+        account: config.account,
+        chain,
+        transport: http(rpcUrl),
+      });
+
+      const publicClient = createPublicClient({
+        chain,
+        transport: http(rpcUrl),
+      });
+
+      const hash = await walletClient.writeContract({
+        address: currency,
+        abi: ERC20_ABI,
+        functionName: "transfer",
+        args: [recipient, amount],
+      });
+
+      await publicClient.waitForTransactionReceipt({ hash });
+
+      return Credential.serialize({
+        challenge,
+        payload: { hash, type: "hash" as const },
+        source: `did:pkh:eip155:${chainId}:${config.account.address}`,
+      });
+    },
+  });
+}

package/src/index.ts

@@ -47,11 +47,12 @@ export async function startMcpServer(): Promise<void> {
         "5. Ask user to rate or tip after a successful run",
         "",
         "PAYMENT:",
-        "- Credit/debit card is the default and easiest way to pay — open the setup page to connect, no funding needed.",
-        "- Crypto wallets (Tempo USDC, Base USDC, Solana USDC) are available for advanced users.",
+        "- Crypto wallets (Tempo USDC, Base USDC, Solana USDC) are the core supported rails.",
+        "- Saved cards can also be used, but card-backed MPP depends on Stripe Shared Payment Token availability in the current environment.",
         "- 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.",
-        "- run_agent() and solve() require pay_with explicitly.",
+        "- When a card is configured, it becomes the default payment method. Use wallet_status to confirm whether `Card MPP: ready` before relying on it.",
+        "- run_agent() and solve() auto-detect the default compatible payment method when pay_with is omitted.",
+        "- Include pay_with explicitly when you need a specific rail or want deterministic control over the payment method used.",
         "- 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.",

package/src/tools/__tests__/jobs.test.ts

@@ -0,0 +1,89 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mockApiGet = vi.fn();
+const mockIsAuthenticated = vi.fn();
+const mockHasWalletConfigured = vi.fn();
+const mockGetWalletAddress = vi.fn();
+const mockFormatRunResult = vi.fn();
+
+vi.mock("../../core/api-client.js", () => ({
+  apiGet: mockApiGet,
+}));
+
+vi.mock("../../core/config.js", () => ({
+  isAuthenticated: mockIsAuthenticated,
+}));
+
+vi.mock("../../core/payments.js", () => ({
+  hasWalletConfigured: mockHasWalletConfigured,
+  getWalletAddress: mockGetWalletAddress,
+}));
+
+vi.mock("../../core/formatters.js", () => ({
+  formatRunResult: mockFormatRunResult,
+}));
+
+function flattenToolText(result: unknown): string {
+  const content = (result as { content?: Array<{ type?: string; text?: string }> })?.content ?? [];
+  return content
+    .filter((item) => item?.type === "text")
+    .map((item) => item.text ?? "")
+    .join("\n\n");
+}
+
+function makeServerHarness() {
+  const handlers = new Map<string, (args: Record<string, unknown>) => Promise<unknown>>();
+  return {
+    handlers,
+    server: {
+      tool(name: string, _description: string, _schema: unknown, handler: (args: Record<string, unknown>) => Promise<unknown>) {
+        handlers.set(name, handler);
+      },
+    },
+  };
+}
+
+describe("job MCP tools", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.clearAllMocks();
+    mockIsAuthenticated.mockReturnValue(false);
+    mockHasWalletConfigured.mockReturnValue(true);
+    mockGetWalletAddress.mockResolvedValue("0xabc123");
+    mockFormatRunResult.mockReturnValue("formatted job result");
+  });
+
+  it("appends the wallet address when looking up a job for an unauthenticated consumer", async () => {
+    mockApiGet.mockResolvedValueOnce({ status: "completed", job_id: "job-123" });
+
+    const { registerJobTools } = await import("../jobs.js");
+    const harness = makeServerHarness();
+    registerJobTools(harness.server as never);
+
+    const getJob = harness.handlers.get("get_job");
+    expect(getJob).toBeDefined();
+
+    const result = await getJob!({ job_id: "job-123" });
+    const text = flattenToolText(result);
+
+    expect(mockApiGet).toHaveBeenCalledWith("/jobs/job-123?wallet=0xabc123");
+    expect(text).toContain("formatted job result");
+  });
+
+  it("returns a processing message while the async job is still running", async () => {
+    mockApiGet.mockResolvedValueOnce({ status: "processing" });
+
+    const { registerJobTools } = await import("../jobs.js");
+    const harness = makeServerHarness();
+    registerJobTools(harness.server as never);
+
+    const getJob = harness.handlers.get("get_job");
+    expect(getJob).toBeDefined();
+
+    const result = await getJob!({ job_id: "job-456" });
+    const text = flattenToolText(result);
+
+    expect(mockApiGet).toHaveBeenCalledWith("/jobs/job-456?wallet=0xabc123");
+    expect(text).toContain("Job job-456 is still processing");
+  });
+});

package/src/tools/__tests__/run.test.ts

@@ -0,0 +1,176 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mockApiGet = vi.fn();
+const mockApiPost = vi.fn();
+const mockApiPostWithPayment = vi.fn();
+const mockGetCompatiblePaymentMethods = vi.fn();
+const mockHasWalletConfigured = vi.fn();
+const mockGetConfiguredMethods = vi.fn();
+const mockGetWalletAddress = vi.fn();
+const mockNormalizePaymentMethod = vi.fn();
+const mockRequiresSpendConfirmation = vi.fn();
+const mockGetDefaultTipAmount = vi.fn();
+const mockCanSpend = vi.fn();
+const mockRecordSpend = vi.fn();
+const mockRequiresPolicyConfirmation = vi.fn();
+const mockUploadLocalFiles = vi.fn();
+const mockStoreFeedbackToken = vi.fn();
+const mockGetActiveCreditPack = vi.fn();
+const mockGetCreditPackInventory = vi.fn();
+const mockGetCreditPackProgram = vi.fn();
+const mockGetOrCreatePendingCardSetup = vi.fn();
+const mockFormatCardSetupBlocks = vi.fn();
+
+vi.mock("../../core/api-client.js", () => ({
+  apiGet: mockApiGet,
+  apiPost: mockApiPost,
+  apiPostWithPayment: mockApiPostWithPayment,
+}));
+
+vi.mock("../../core/card-setup.js", () => ({
+  getOrCreatePendingCardSetup: mockGetOrCreatePendingCardSetup,
+  formatCardSetupBlocks: mockFormatCardSetupBlocks,
+}));
+
+vi.mock("../../core/payments.js", () => ({
+  getCompatiblePaymentMethods: mockGetCompatiblePaymentMethods,
+  getConfiguredMethods: mockGetConfiguredMethods,
+  hasWalletConfigured: mockHasWalletConfigured,
+  getWalletAddress: mockGetWalletAddress,
+  normalizePaymentMethod: mockNormalizePaymentMethod,
+}));
+
+vi.mock("../../core/config.js", () => ({
+  requiresSpendConfirmation: mockRequiresSpendConfirmation,
+  getDefaultTipAmount: mockGetDefaultTipAmount,
+}));
+
+vi.mock("../../core/spend-policy.js", () => ({
+  canSpend: mockCanSpend,
+  recordSpend: mockRecordSpend,
+  requiresPolicyConfirmation: mockRequiresPolicyConfirmation,
+}));
+
+vi.mock("../../core/file-upload.js", () => ({
+  uploadLocalFiles: mockUploadLocalFiles,
+}));
+
+vi.mock("../_token-cache.js", () => ({
+  storeFeedbackToken: mockStoreFeedbackToken,
+}));
+
+vi.mock("../../core/passes.js", () => ({
+  formatCreditPackOffer: vi.fn(),
+  getActiveCreditPack: mockGetActiveCreditPack,
+  getCreditPackInventory: mockGetCreditPackInventory,
+  getCreditPackProgram: mockGetCreditPackProgram,
+}));
+
+function flattenToolText(result: unknown): string {
+  const content = (result as { content?: Array<{ type?: string; text?: string }> })?.content ?? [];
+  return content
+    .filter((item) => item?.type === "text")
+    .map((item) => item.text ?? "")
+    .join("\n\n");
+}
+
+function makeServerHarness() {
+  const handlers = new Map<string, (args: Record<string, unknown>) => Promise<unknown>>();
+  return {
+    handlers,
+    server: {
+      tool(name: string, _description: string, _schema: unknown, handler: (args: Record<string, unknown>) => Promise<unknown>) {
+        handlers.set(name, handler);
+      },
+    },
+  };
+}
+
+const selectedAgent = {
+  id: "agent-1",
+  name: "MockFixedPrice",
+  pricePerRunUsd: "0.01",
+  tags: ["translation"],
+  mcpSchema: null,
+};
+
+describe("run_agent MCP tool", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.clearAllMocks();
+
+    mockHasWalletConfigured.mockReturnValue(true);
+    mockGetConfiguredMethods.mockReturnValue(["card"]);
+    mockGetCompatiblePaymentMethods.mockReturnValue(["card"]);
+    mockNormalizePaymentMethod.mockImplementation((method: string) => method);
+    mockRequiresSpendConfirmation.mockReturnValue(true);
+    mockGetDefaultTipAmount.mockReturnValue(0);
+    mockCanSpend.mockReturnValue({ ok: true, message: "" });
+    mockRequiresPolicyConfirmation.mockReturnValue(false);
+    mockUploadLocalFiles.mockResolvedValue({ input: { text: "hello", target_language: "es" }, uploads: [] });
+    mockGetActiveCreditPack.mockReturnValue(null);
+    mockGetCreditPackInventory.mockResolvedValue([]);
+    mockGetCreditPackProgram.mockReturnValue(null);
+    mockGetOrCreatePendingCardSetup.mockResolvedValue({ url: "https://example.com/card-setup" });
+    mockFormatCardSetupBlocks.mockReturnValue(["card setup"]);
+    mockGetWalletAddress.mockResolvedValue("0xabc");
+    mockApiGet.mockResolvedValue(selectedAgent);
+  });
+
+  it("quotes explicit agent execution before running", async () => {
+    const { registerRunTools } = await import("../run.js");
+    const harness = makeServerHarness();
+    registerRunTools(harness.server as never);
+
+    const runAgent = harness.handlers.get("run_agent");
+    expect(runAgent).toBeDefined();
+
+    const result = await runAgent!({
+      agent_id: selectedAgent.id,
+      input: { text: "hello", target_language: "es" },
+      pay_with: "card",
+    });
+    const text = flattenToolText(result);
+
+    expect(text).toContain("Ready to run MockFixedPrice");
+    expect(text).toContain('run_agent({ agent_id: "agent-1", input: <same>, pay_with: "card", confirmed: true })');
+    expect(mockApiPostWithPayment).not.toHaveBeenCalled();
+  });
+
+  it("runs the explicitly selected agent when confirmed", async () => {
+    mockApiPostWithPayment.mockResolvedValueOnce({
+      status: "success",
+      job_id: "job-1",
+      agent_id: selectedAgent.id,
+      agent_name: selectedAgent.name,
+      output: { translated_text: "hola" },
+      cost: 0.01,
+    });
+
+    const { registerRunTools } = await import("../run.js");
+    const harness = makeServerHarness();
+    registerRunTools(harness.server as never);
+
+    const runAgent = harness.handlers.get("run_agent");
+    expect(runAgent).toBeDefined();
+
+    const result = await runAgent!({
+      agent_id: selectedAgent.id,
+      input: { text: "hello", target_language: "es" },
+      pay_with: "card",
+      confirmed: true,
+    });
+    const text = flattenToolText(result);
+
+    expect(mockApiPostWithPayment).toHaveBeenCalledWith(
+      "/agents/agent-1/run",
+      { input: { text: "hello", target_language: "es" } },
+      "card",
+    );
+    expect(mockRecordSpend).toHaveBeenCalledWith("card", 0.01);
+    expect(text).toContain("translated_text");
+    expect(text).toContain("✓ MockFixedPrice");
+    expect(text).toContain("Paid: $0.01 via card");
+    expect(text).toContain("Job ID: job-1");
+  });
+});

package/src/tools/__tests__/solve.test.ts

@@ -0,0 +1,186 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mockApiGet = vi.fn();
+const mockApiPost = vi.fn();
+const mockApiPostWithPayment = vi.fn();
+const mockGetCompatiblePaymentMethods = vi.fn();
+const mockHasWalletConfigured = vi.fn();
+const mockGetConfiguredMethods = vi.fn();
+const mockGetAcceptedPaymentMethods = vi.fn();
+const mockGetWalletAddress = vi.fn();
+const mockNormalizePaymentMethod = vi.fn();
+const mockToRegistryPaymentMethod = vi.fn();
+const mockRequiresSpendConfirmation = vi.fn();
+const mockGetDefaultTipAmount = vi.fn();
+const mockCanSpend = vi.fn();
+const mockRecordSpend = vi.fn();
+const mockRequiresPolicyConfirmation = vi.fn();
+const mockUploadLocalFiles = vi.fn();
+const mockStoreFeedbackToken = vi.fn();
+const mockGetActiveCreditPack = vi.fn();
+const mockGetCreditPackInventory = vi.fn();
+const mockGetCreditPackProgram = vi.fn();
+const mockGetOrCreatePendingCardSetup = vi.fn();
+const mockFormatCardSetupBlocks = vi.fn();
+
+vi.mock("../../core/api-client.js", () => ({
+  apiGet: mockApiGet,
+  apiPost: mockApiPost,
+  apiPostWithPayment: mockApiPostWithPayment,
+}));
+
+vi.mock("../../core/card-setup.js", () => ({
+  getOrCreatePendingCardSetup: mockGetOrCreatePendingCardSetup,
+  formatCardSetupBlocks: mockFormatCardSetupBlocks,
+}));
+
+vi.mock("../../core/payments.js", () => ({
+  getCompatiblePaymentMethods: mockGetCompatiblePaymentMethods,
+  hasWalletConfigured: mockHasWalletConfigured,
+  getConfiguredMethods: mockGetConfiguredMethods,
+  getAcceptedPaymentMethods: mockGetAcceptedPaymentMethods,
+  getWalletAddress: mockGetWalletAddress,
+  normalizePaymentMethod: mockNormalizePaymentMethod,
+  toRegistryPaymentMethod: mockToRegistryPaymentMethod,
+}));
+
+vi.mock("../../core/config.js", () => ({
+  requiresSpendConfirmation: mockRequiresSpendConfirmation,
+  getDefaultTipAmount: mockGetDefaultTipAmount,
+}));
+
+vi.mock("../../core/spend-policy.js", () => ({
+  canSpend: mockCanSpend,
+  recordSpend: mockRecordSpend,
+  requiresPolicyConfirmation: mockRequiresPolicyConfirmation,
+}));
+
+vi.mock("../../core/file-upload.js", () => ({
+  uploadLocalFiles: mockUploadLocalFiles,
+}));
+
+vi.mock("../_token-cache.js", () => ({
+  storeFeedbackToken: mockStoreFeedbackToken,
+}));
+
+vi.mock("../../core/passes.js", () => ({
+  getActiveCreditPack: mockGetActiveCreditPack,
+  getCreditPackInventory: mockGetCreditPackInventory,
+  getCreditPackProgram: mockGetCreditPackProgram,
+}));
+
+function flattenToolText(result: unknown): string {
+  const content = (result as { content?: Array<{ type?: string; text?: string }> })?.content ?? [];
+  return content
+    .filter((item) => item?.type === "text")
+    .map((item) => item.text ?? "")
+    .join("\n\n");
+}
+
+function makeServerHarness() {
+  const handlers = new Map<string, (args: Record<string, unknown>) => Promise<unknown>>();
+  return {
+    handlers,
+    server: {
+      tool(name: string, _description: string, _schema: unknown, handler: (args: Record<string, unknown>) => Promise<unknown>) {
+        handlers.set(name, handler);
+      },
+    },
+  };
+}
+
+const selectedAgent = {
+  id: "agent-1",
+  name: "MockFixedPrice",
+  pricePerRunUsd: "0.01",
+  tags: ["translation"],
+  mcpSchema: null,
+};
+
+describe("solve MCP tool", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.clearAllMocks();
+
+    mockHasWalletConfigured.mockReturnValue(true);
+    mockGetConfiguredMethods.mockReturnValue(["card"]);
+    mockGetAcceptedPaymentMethods.mockReturnValue(["card"]);
+    mockGetCompatiblePaymentMethods.mockReturnValue(["card"]);
+    mockNormalizePaymentMethod.mockImplementation((method: string) => method);
+    mockToRegistryPaymentMethod.mockImplementation((method: string) => method);
+    mockRequiresSpendConfirmation.mockReturnValue(true);
+    mockGetDefaultTipAmount.mockReturnValue(0);
+    mockCanSpend.mockReturnValue({ ok: true, message: "" });
+    mockRequiresPolicyConfirmation.mockReturnValue(false);
+    mockUploadLocalFiles.mockResolvedValue({ input: { text: "hello", target_language: "es" }, uploads: [] });
+    mockGetActiveCreditPack.mockReturnValue(null);
+    mockGetCreditPackInventory.mockResolvedValue([]);
+    mockGetCreditPackProgram.mockReturnValue(null);
+    mockGetOrCreatePendingCardSetup.mockResolvedValue({ url: "https://example.com/card-setup" });
+    mockFormatCardSetupBlocks.mockReturnValue(["card setup"]);
+    mockGetWalletAddress.mockResolvedValue("0xabc");
+  });
+
+  it("falls back to a quoted confirmation flow when /solve returns a 402 challenge", async () => {
+    mockApiPost.mockRejectedValueOnce(Object.assign(new Error("Payment Required"), { status: 402 }));
+    mockApiGet.mockResolvedValueOnce([selectedAgent]);
+
+    const { registerSolveTools } = await import("../solve.js");
+    const harness = makeServerHarness();
+    registerSolveTools(harness.server as never);
+
+    const solve = harness.handlers.get("solve");
+    expect(solve).toBeDefined();
+
+    const result = await solve!({
+      intent: "MockFixedPrice",
+      input: { text: "hello", target_language: "es" },
+      budget: 0.05,
+      pay_with: "card",
+    });
+    const text = flattenToolText(result);
+
+    expect(text).toContain("Best match: MockFixedPrice");
+    expect(text).toContain('solve({ intent: "MockFixedPrice"');
+    expect(text).toContain('pay_with: "card"');
+    expect(mockApiPostWithPayment).not.toHaveBeenCalled();
+  });
+
+  it("falls back to paid execution when confirmed after a 402 challenge", async () => {
+    mockApiPost.mockRejectedValueOnce(Object.assign(new Error("Payment Required"), { status: 402 }));
+    mockApiGet.mockResolvedValueOnce([selectedAgent]);
+    mockApiPostWithPayment.mockResolvedValueOnce({
+      status: "success",
+      job_id: "job-1",
+      agent_id: selectedAgent.id,
+      agent_name: selectedAgent.name,
+      output: { translated_text: "hola" },
+      cost: 0.01,
+    });
+
+    const { registerSolveTools } = await import("../solve.js");
+    const harness = makeServerHarness();
+    registerSolveTools(harness.server as never);
+
+    const solve = harness.handlers.get("solve");
+    expect(solve).toBeDefined();
+
+    const result = await solve!({
+      intent: "MockFixedPrice",
+      input: { text: "hello", target_language: "es" },
+      budget: 0.05,
+      pay_with: "card",
+      confirmed: true,
+    });
+    const text = flattenToolText(result);
+
+    expect(mockApiPostWithPayment).toHaveBeenCalledWith(
+      "/agents/agent-1/run",
+      { input: { text: "hello", target_language: "es" } },
+      "card",
+    );
+    expect(text).toContain("Running MockFixedPrice — best match");
+    expect(text).toContain("Job ID: job-1");
+    expect(text).toContain("Paid: $0.01 via card");
+  });
+});