fix: mcp pay fetch (#69)

* fix: mcp pay fetch

* resolve comments

* resolve comments

* set default timeout to 30s

Author: kevzzsk

packages/use-agently-sdk/a2a.test.ts

@@ -1,4 +1,4 @@
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { afterAll, beforeAll, describe, expect, setDefaultTimeout, test } from "bun:test";
 import { randomUUID } from "node:crypto";
 import { extractAgentText, extractStreamEventText, sendA2AMessage, sendA2AMessageStream, getA2ACard } from "./a2a";
 import { createA2AClient, createPaymentFetch, createDryRunFetch, DryRunPaymentRequired } from "./client";
@@ -13,6 +13,8 @@ import {
 } from "./testing";
 import { accounts } from "x402-fl/testcontainers";
 
+setDefaultTimeout(30_000);
+
 describe("extractAgentText", () => {
   test("returns fallback for null/undefined result", () => {
     expect(extractAgentText(null)).toStrictEqual("The agent processed your request but returned no response.");

packages/use-agently-sdk/mcp.test.ts

@@ -1,6 +1,7 @@
-import { afterAll, beforeAll, describe, expect, test, spyOn } from "bun:test";
+import { afterAll, beforeAll, describe, expect, setDefaultTimeout, test, spyOn } from "bun:test";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { generatePrivateKey } from "viem/accounts";
 import { listMcpTools, callMcpTool } from "./mcp";
 import { createMcpPaymentClient, DryRunPaymentRequired, USER_AGENT } from "./client";
 import { EvmPrivateKeyWallet } from "./wallets/evm-private-key";
@@ -15,6 +16,8 @@ import {
 import { accounts } from "x402-fl/testcontainers";
 import pkg from "./package.json" with { type: "json" };
 
+setDefaultTimeout(30_000);
+
 let fixture: X402FacilitatorLocal;
 
 beforeAll(async () => {
@@ -36,7 +39,7 @@ async function createMcpClient(): Promise<Client> {
   return client;
 }
 
-describe("mcp free (sdk)", () => {
+describe("mcp free", () => {
   test("calls echo tool and returns text content", async () => {
     const client = await createMcpClient();
     try {
@@ -54,7 +57,7 @@ describe("mcp free (sdk)", () => {
   });
 });
 
-describe("mcp x402 payment (sdk)", () => {
+describe("mcp x402 payment", () => {
   test("paid tool call succeeds with funded wallet and debits sender exactly $0.001", async () => {
     const wallet = new EvmPrivateKeyWallet(TEST_PRIVATE_KEY, fixture.container.getRpcUrl());
     const client = await createMcpClient();
@@ -89,7 +92,7 @@ describe("mcp x402 payment (sdk)", () => {
   });
 });
 
-describe("listMcpTools (high-level)", () => {
+describe("listMcpTools", () => {
   test("returns array including echo tool", async () => {
     const tools = await listMcpTools(mcpUrl());
     expect(Array.isArray(tools)).toBe(true);
@@ -109,7 +112,7 @@ describe("listMcpTools (high-level)", () => {
   });
 });
 
-describe("callMcpTool (high-level)", () => {
+describe("callMcpTool", () => {
   test("free tool call succeeds in dry-run mode", async () => {
     const result = await callMcpTool(mcpUrl(), "echo", { message: "hello high-level" });
     const content = result.content as Array<{ type: string; text: string }>;
@@ -152,4 +155,91 @@ describe("callMcpTool (high-level)", () => {
       expect(err.message).toContain("USDC");
     }
   });
+
+  test("custom fetchImpl is used for paid tool call", async () => {
+    const wallet = new EvmPrivateKeyWallet(TEST_PRIVATE_KEY, fixture.container.getRpcUrl());
+    const spy = spyOn(globalThis, "fetch");
+    try {
+      // @ts-expect-error — Bun's typeof fetch includes preconnect namespace (oven-sh/bun#23741)
+      const customFetch: typeof fetch = (input, init) => {
+        const headers = new Headers(init?.headers);
+        headers.set("X-Custom-Header", "pay-test");
+        return globalThis.fetch(input, { ...init, headers });
+      };
+
+      const result = await callMcpTool(
+        mcpUrl(),
+        "paid-echo-tool",
+        { message: "hello custom fetch pay" },
+        {
+          transaction: PayTransaction(wallet),
+          fetchImpl: customFetch,
+        },
+      );
+      const content = result.content as Array<{ type: string; text: string }>;
+      expect(content[0].text).toStrictEqual("hello custom fetch pay");
+
+      // Verify the custom header was sent on at least one underlying fetch call
+      const hasCustomHeader = spy.mock.calls.some((call) => {
+        const headers = new Headers(call[1]?.headers);
+        return headers.get("X-Custom-Header") === "pay-test";
+      });
+      expect(hasCustomHeader).toBe(true);
+    } finally {
+      spy.mockRestore();
+    }
+  });
+
+  test("custom fetchImpl is used for dry-run tool call", async () => {
+    const spy = spyOn(globalThis, "fetch");
+    try {
+      // @ts-expect-error — Bun's typeof fetch includes preconnect namespace (oven-sh/bun#23741)
+      const customFetch: typeof fetch = (input, init) => {
+        const headers = new Headers(init?.headers);
+        headers.set("X-Custom-Header", "dryrun-test");
+        return globalThis.fetch(input, { ...init, headers });
+      };
+
+      const result = await callMcpTool(
+        mcpUrl(),
+        "echo",
+        { message: "hello custom fetch dryrun" },
+        { fetchImpl: customFetch },
+      );
+      const content = result.content as Array<{ type: string; text: string }>;
+      expect(content[0].text).toStrictEqual("hello custom fetch dryrun");
+
+      const hasCustomHeader = spy.mock.calls.some((call) => {
+        const headers = new Headers(call[1]?.headers);
+        return headers.get("X-Custom-Header") === "dryrun-test";
+      });
+      expect(hasCustomHeader).toBe(true);
+    } finally {
+      spy.mockRestore();
+    }
+  });
+
+  test("paid tool with unfunded wallet returns isError with insufficient_funds", async () => {
+    const unfundedKey = generatePrivateKey();
+    const unfundedWallet = new EvmPrivateKeyWallet(unfundedKey, fixture.container.getRpcUrl());
+
+    const result = await callMcpTool(
+      mcpUrl(),
+      "paid-echo-tool",
+      { message: "should fail — no funds" },
+      { transaction: PayTransaction(unfundedWallet) },
+    );
+
+    expect(result.isError).toStrictEqual(true);
+
+    const content = result.content as Array<{ type: string; text?: string }>;
+    expect(content.length).toBeGreaterThan(0);
+    expect(content[0].type).toStrictEqual("text");
+
+    const parsed = JSON.parse(content[0].text!);
+    expect(parsed.x402Version).toBeDefined();
+    expect(parsed.accepts).toBeDefined();
+    expect(Array.isArray(parsed.accepts)).toBe(true);
+    expect(parsed.error).toContain("insufficient_funds");
+  });
 });

packages/use-agently-sdk/mcp.ts

@@ -2,8 +2,10 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import type { Tool } from "@modelcontextprotocol/sdk/types.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { DryRunPaymentRequired, resolveFetchForTransaction, createMcpPaymentClient } from "./client.js";
-import { DryRunTransaction, type TransactionMode } from "./utils/transaction.js";
+import type { x402MCPClient, x402MCPToolCallResult } from "@x402/mcp";
+import { DryRunPaymentRequired, resolveFetchForTransaction, createMcpPaymentClient, clientFetch } from "./client.js";
+import { DryRunTransaction, PayTransaction, type TransactionMode } from "./utils/transaction.js";
+import type { Wallet } from "./wallets/wallet.js";
 import pkg from "./package.json" with { type: "json" };
 
 export interface McpCallOptions {
@@ -22,15 +24,30 @@ export function resolveMcpUrl(input: string): string {
   return url.toString();
 }
 
+async function createMcpClient(
+  mcpUrl: string,
+  options: { clientInfo?: { name: string; version: string }; fetchImpl?: typeof fetch; wallet: Wallet },
+): Promise<x402MCPClient>;
 async function createMcpClient(
   mcpUrl: string,
   options?: { clientInfo?: { name: string; version: string }; fetchImpl?: typeof fetch },
-): Promise<Client> {
+): Promise<Client>;
+async function createMcpClient(
+  mcpUrl: string,
+  options?: { clientInfo?: { name: string; version: string }; fetchImpl?: typeof fetch; wallet?: Wallet },
+): Promise<Client | x402MCPClient> {
   const client = new Client(options?.clientInfo ?? { name: "@use-agently/sdk", version: pkg.version });
   const transport = new StreamableHTTPClientTransport(
     new URL(mcpUrl),
     options?.fetchImpl ? { fetch: options.fetchImpl } : undefined,
   );
+
+  if (options?.wallet) {
+    const x402Client = createMcpPaymentClient(client, options.wallet);
+    await x402Client.connect(transport);
+    return x402Client;
+  }
+
   await client.connect(transport);
   return client;
 }
@@ -49,23 +66,47 @@ export async function listMcpTools(uri: string, options?: McpCallOptions): Promi
 }
 
 /** Call a tool on an MCP server, with optional payment support. Defaults to dry-run mode. */
+export async function callMcpTool(uri: string, tool: string, args?: Record<string, unknown>): Promise<CallToolResult>;
+export async function callMcpTool(
+  uri: string,
+  tool: string,
+  args: Record<string, unknown> | undefined,
+  options: McpCallOptions & { transaction: PayTransaction },
+): Promise<x402MCPToolCallResult>;
+export async function callMcpTool(
+  uri: string,
+  tool: string,
+  args: Record<string, unknown> | undefined,
+  options: McpCallOptions & { transaction: DryRunTransaction },
+): Promise<CallToolResult>;
+export async function callMcpTool(
+  uri: string,
+  tool: string,
+  args: Record<string, unknown> | undefined,
+  options: McpCallOptions,
+): Promise<CallToolResult | x402MCPToolCallResult>;
 export async function callMcpTool(
   uri: string,
   tool: string,
   args?: Record<string, unknown>,
   options?: McpCallOptions,
-): Promise<CallToolResult> {
+): Promise<CallToolResult | x402MCPToolCallResult> {
   const mcpUrl = resolveMcpUrl(uri);
   const transaction = options?.transaction ?? DryRunTransaction;
   const resolvedFetch = resolveFetchForTransaction(transaction, options?.fetchImpl);
 
   if (transaction.mode === "pay") {
-    const client = await createMcpClient(mcpUrl, { clientInfo: options?.clientInfo, fetchImpl: resolvedFetch });
+    // Use the caller's fetchImpl (e.g. User-Agent), but skip the payment-wrapped fetch —
+    // x402MCPClient handles payment at the MCP protocol level.
+    const x402Client = await createMcpClient(mcpUrl, {
+      clientInfo: options?.clientInfo,
+      fetchImpl: options?.fetchImpl ?? clientFetch,
+      wallet: transaction.wallet,
+    });
     try {
-      const x402Client = createMcpPaymentClient(client, transaction.wallet);
-      return (await x402Client.callTool(tool, args ?? {})) as unknown as CallToolResult;
+      return await x402Client.callTool(tool, args ?? {});
     } finally {
-      await client.close();
+      await x402Client.close();
     }
   }
 
@@ -78,7 +119,7 @@ export async function callMcpTool(
       if (content?.length > 0 && content[0].type === "text" && content[0].text) {
         try {
           const parsed = JSON.parse(content[0].text);
-          if (parsed?.accepts) {
+          if (Array.isArray(parsed?.accepts) && parsed.accepts.length > 0) {
             throw new DryRunPaymentRequired(parsed.accepts);
           }
         } catch (e) {

packages/use-agently/src/commands/a2a.test.ts

@@ -1,4 +1,4 @@
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { afterAll, beforeAll, describe, expect, setDefaultTimeout, test } from "bun:test";
 import { randomUUID } from "node:crypto";
 import { EvmPrivateKeyWallet, DryRunPaymentRequired, createA2AClient } from "@use-agently/sdk";
 import { accounts } from "x402-fl/testcontainers";
@@ -16,6 +16,8 @@ import {
 } from "../testing";
 import { extractAgentText } from "./a2a";
 
+setDefaultTimeout(30_000);
+
 mockConfigModule();
 
 const { cli } = await import("../cli");