aixyz 0.33.0 → 0.35.0

package/accepts.ts

@@ -1,32 +1,47 @@
 import { z } from "zod";
 import { FacilitatorClient, HTTPFacilitatorClient } from "@x402/core/server";
 
-export type Accepts = AcceptsX402 | AcceptsFree;
-
-export type AcceptsX402 = {
-  scheme: "exact";
-  price: string;
+const AcceptsX402Scheme = z.object({
+  scheme: z.literal("exact"),
+  price: z.string(),
   // TODO(kevin): update type to Network (`string:string`)
-  network?: string;
-  payTo?: string;
-};
-
-export type AcceptsFree = {
-  scheme: "free";
-};
-
-export const AcceptsScheme = z.discriminatedUnion("scheme", [
-  z.object({
-    scheme: z.literal("exact"),
-    price: z.string(),
-    network: z.string().optional(),
-    payTo: z.string().optional(),
-  }),
-  z.object({
-    scheme: z.literal("free"),
-  }),
+  network: z.string().optional(),
+  payTo: z.string().optional(),
+});
+
+/** Used for multiple accepts — explicit network is required to properly register schemes on the resource server. */
+const AcceptsX402EntryScheme = z.object({
+  scheme: z.literal("exact"),
+  price: z.string(),
+  network: z.string(),
+  payTo: z.string().optional(),
+});
+
+const AcceptsFreeScheme = z.object({
+  scheme: z.literal("free"),
+});
+
+export type AcceptsX402 = z.infer<typeof AcceptsX402Scheme>;
+export type AcceptsX402Entry = z.infer<typeof AcceptsX402EntryScheme>;
+export type AcceptsX402Multi = AcceptsX402Entry[];
+export type AcceptsFree = z.infer<typeof AcceptsFreeScheme>;
+export type Accepts = AcceptsX402 | AcceptsFree | AcceptsX402Multi;
+
+export const AcceptsScheme: z.ZodType<Accepts> = z.union([
+  z.discriminatedUnion("scheme", [AcceptsX402Scheme, AcceptsFreeScheme]),
+  z.array(AcceptsX402EntryScheme).min(1),
 ]);
 
+export function normalizeAcceptsX402(accepts: AcceptsX402 | AcceptsX402Multi): AcceptsX402[] {
+  return Array.isArray(accepts) ? accepts : [accepts];
+}
+
+export function isAcceptsPaid(accepts: Accepts): accepts is AcceptsX402 | AcceptsX402Multi {
+  if (Array.isArray(accepts))
+    return accepts.length > 0 && accepts.every((e) => e.scheme === "exact" && typeof e.network === "string");
+  return accepts.scheme === "exact";
+}
+
 export type { FacilitatorClient };
 
 export { HTTPFacilitatorClient };

package/app/index.ts

@@ -1,11 +1,11 @@
-import type { AcceptsX402 } from "../accepts";
+import { isAcceptsPaid, AcceptsScheme } from "../accepts";
+import type { Accepts } from "../accepts";
 import type { FacilitatorClient } from "@x402/core/server";
-import { type HttpMethod, type RouteHandler, type Middleware, type RouteEntry } from "./types";
+import { type HttpMethod, type RouteHandler, type Middleware, type RouteEntry, type RouteOptions } from "./types";
 import { PaymentGateway } from "./payment/payment";
-import { Network } from "@x402/core/types";
 import { getAixyzConfig } from "@aixyz/config";
 import { loadEnvConfig } from "@next/env";
-import { BasePlugin, type RegisterContext, type InitializeContext } from "./plugin";
+import { BasePlugin, type RegisterContext, type InitializeContext, type PaymentHookContext } from "./plugin";
 
 // Load .env and .env.production files at runtime (local files are excluded at build time).
 loadEnvConfig(process.cwd());
@@ -37,7 +37,6 @@ export class AixyzApp {
 
     if (options?.facilitators) {
       this.payment = new PaymentGateway(options.facilitators, config);
-      this.payment.register((config.x402.network as Network) ?? "eip155:8453");
     }
   }
 
@@ -69,6 +68,35 @@ export class AixyzApp {
     // clear registered routes for this plugin before registration, in case of hot reload or multiple registrations
     plugin.registeredRoutes.clear();
 
+    const paymentHooks: PaymentHookContext | undefined = this.payment
+      ? {
+          onBeforeVerify: (h) => {
+            this.payment!.onBeforeVerify(h);
+            return paymentHooks!;
+          },
+          onAfterVerify: (h) => {
+            this.payment!.onAfterVerify(h);
+            return paymentHooks!;
+          },
+          onVerifyFailure: (h) => {
+            this.payment!.onVerifyFailure(h);
+            return paymentHooks!;
+          },
+          onBeforeSettle: (h) => {
+            this.payment!.onBeforeSettle(h);
+            return paymentHooks!;
+          },
+          onAfterSettle: (h) => {
+            this.payment!.onAfterSettle(h);
+            return paymentHooks!;
+          },
+          onSettleFailure: (h) => {
+            this.payment!.onSettleFailure(h);
+            return paymentHooks!;
+          },
+        }
+      : undefined;
+
     const ctx: RegisterContext = {
       route: (method, path, handler, options) => {
         this.route(method, path, handler, options);
@@ -77,6 +105,7 @@ export class AixyzApp {
         if (entry) plugin.registeredRoutes.set(key, entry);
       },
       use: (mw) => this.use(mw),
+      paymentHooks,
     };
     await plugin.register?.(ctx);
     return this;
@@ -87,14 +116,21 @@ export class AixyzApp {
     return `${method} ${path}`;
   }
 
-  /** Register a route with an optional x402 payment requirement. */
-  route(method: HttpMethod, path: string, handler: RouteHandler, options?: { payment?: AcceptsX402 }): void {
+  /** Register a route with an optional x402 payment requirement. Free accepts are filtered out. */
+  route(method: HttpMethod, path: string, handler: RouteHandler, options?: RouteOptions): void {
     const key = this.getRouteKey(method, path);
+    if (options?.payment) {
+      const result = AcceptsScheme.safeParse(options.payment);
+      if (!result.success) {
+        throw new Error(`Invalid accepts config for route "${method} ${path}": ${result.error.message}`);
+      }
+    }
+    const payment = options?.payment && isAcceptsPaid(options.payment) ? options.payment : undefined;
     this.routes.set(key, {
       method,
       path,
       handler,
-      payment: options?.payment,
+      payment,
     });
   }
 

package/app/payment/payment.ts

@@ -8,10 +8,56 @@ import {
   type HTTPResponseInstructions,
 } from "@x402/core/http";
 import { ExactEvmScheme } from "@x402/evm/exact/server";
-import type { AcceptsX402 } from "../../accepts";
-import { Network, PaymentPayload, PaymentRequirements } from "@x402/core/types";
+import type { AcceptsX402, AcceptsX402Multi } from "../../accepts";
+import { normalizeAcceptsX402 } from "../../accepts";
+import { Network, PaymentPayload, PaymentRequirements, VerifyResponse, SettleResponse } from "@x402/core/types";
 import { AixyzConfig } from "@aixyz/config";
 
+// ── x402 Lifecycle Hook Types ──────────────────────────────────────────
+// These mirror x402ResourceServer's hook signatures but are defined here
+// because x402/core does not export them publicly.
+
+export interface VerifyContext {
+  paymentPayload: PaymentPayload;
+  requirements: PaymentRequirements;
+}
+
+export interface VerifyResultContext extends VerifyContext {
+  result: VerifyResponse;
+}
+
+export interface VerifyFailureContext extends VerifyContext {
+  error: Error;
+}
+
+export interface SettleContext {
+  paymentPayload: PaymentPayload;
+  requirements: PaymentRequirements;
+}
+
+export interface SettleResultContext extends SettleContext {
+  result: SettleResponse;
+}
+
+export interface SettleFailureContext extends SettleContext {
+  error: Error;
+}
+
+export type BeforeVerifyHook = (
+  context: VerifyContext,
+) => Promise<void | { abort: true; reason: string; message?: string }>;
+export type AfterVerifyHook = (context: VerifyResultContext) => Promise<void>;
+export type OnVerifyFailureHook = (
+  context: VerifyFailureContext,
+) => Promise<void | { recovered: true; result: VerifyResponse }>;
+export type BeforeSettleHook = (
+  context: SettleContext,
+) => Promise<void | { abort: true; reason: string; message?: string }>;
+export type AfterSettleHook = (context: SettleResultContext) => Promise<void>;
+export type OnSettleFailureHook = (
+  context: SettleFailureContext,
+) => Promise<void | { recovered: true; result: SettleResponse }>;
+
 /**
  * Converts a web-standard Request into the x402 HTTPAdapter interface.
  */
@@ -44,10 +90,12 @@ function toResponse(instructions: HTTPResponseInstructions): Response {
   return new Response(body, { status: instructions.status, headers });
 }
 
-interface PaymentContext {
+export interface PaymentContext {
   paymentPayload: PaymentPayload;
   paymentRequirements: PaymentRequirements;
   declaredExtensions?: Record<string, unknown>;
+  /** The payer's address, captured from x402 verification. */
+  payer?: string;
 }
 
 /**
@@ -59,10 +107,22 @@ export class PaymentGateway {
   private readonly config: AixyzConfig;
   private readonly pendingRoutes = new Map<string, RouteConfig>();
   private readonly verifiedPayments = new WeakMap<Request, PaymentContext>();
+  /**
+   * Temporary map to capture payer address from the afterVerify hook.
+   * Keyed by PaymentPayload reference (same object flows through the verify pipeline).
+   */
+  private readonly pendingPayers = new WeakMap<PaymentPayload, string>();
 
   constructor(facilitators: FacilitatorClient | FacilitatorClient[], config: AixyzConfig) {
     this.resourceServer = new x402ResourceServer(facilitators);
     this.config = config;
+
+    // Capture payer address from verification so it can be exposed to handlers.
+    this.onAfterVerify(async (context) => {
+      if (context.result.payer) {
+        this.pendingPayers.set(context.paymentPayload, context.result.payer);
+      }
+    });
   }
 
   /** Register an EVM payment scheme for the given network (e.g. Base mainnet). */
@@ -78,29 +138,49 @@ export class PaymentGateway {
   /**
    * Add a payment-gated route. Must be called before initialize().
    */
-  addRoute(method: string, path: string, accepts: AcceptsX402): void {
+  addRoute(method: string, path: string, accepts: AcceptsX402 | AcceptsX402Multi): void {
     const pattern = this.getRouteKey(method, path);
+    const items = normalizeAcceptsX402(accepts);
     this.pendingRoutes.set(pattern, {
-      accepts: {
-        scheme: accepts.scheme,
-        payTo: accepts.payTo ?? this.config.x402.payTo,
-        price: accepts.price,
-        network: (accepts.network as Network) ?? (this.config.x402.network as Network),
-      },
+      accepts: items.map((a) => ({
+        scheme: a.scheme,
+        payTo: a.payTo ?? this.config.x402.payTo,
+        price: a.price,
+        network: (a.network as Network) ?? (this.config.x402.network as Network),
+      })),
     });
   }
 
   /**
-   * Initialize the payment gateway. Builds the x402HTTPResourceServer from registered routes.
+   * Initialize the payment gateway. Registers all required network schemes
+   * from pending routes, then builds the x402HTTPResourceServer.
    * Must be called after all routes are added.
    */
   async initialize(): Promise<void> {
+    this.registerNetworksFromRoutes();
     const routes: RoutesConfig =
       this.pendingRoutes.size > 0 ? Object.fromEntries(this.pendingRoutes) : { "* /*": { accepts: [] } };
     this.httpServer = new x402HTTPResourceServer(this.resourceServer, routes);
     await this.httpServer.initialize();
   }
 
+  private registerNetworksFromRoutes(): void {
+    const networks = new Set<Network>();
+    const defaultNetwork = (this.config.x402.network as Network) ?? ("eip155:8453" as Network);
+    networks.add(defaultNetwork);
+
+    for (const [, route] of this.pendingRoutes) {
+      const accepts = Array.isArray(route.accepts) ? route.accepts : [route.accepts];
+      for (const opt of accepts) {
+        if (opt.network) networks.add(opt.network as Network);
+      }
+    }
+
+    for (const network of networks) {
+      this.register(network);
+    }
+  }
+
   /**
    * Verify payment for a request. Returns a 402 Response if payment is required/invalid,
    * or null if the request is authorized to proceed.
@@ -124,13 +204,16 @@ export class PaymentGateway {
       case "no-payment-required":
         return null;
 
-      case "payment-verified":
+      case "payment-verified": {
+        const payer = this.pendingPayers.get(result.paymentPayload);
         this.verifiedPayments.set(request, {
           paymentPayload: result.paymentPayload,
           paymentRequirements: result.paymentRequirements,
           declaredExtensions: result.declaredExtensions,
+          payer,
         });
         return null;
+      }
 
       case "payment-error":
         return toResponse(result.response);
@@ -154,4 +237,58 @@ export class PaymentGateway {
 
     return result;
   }
+
+  /**
+   * Get the payer's address for a verified payment request.
+   * Available after `verify()` succeeds and before `settle()` is called.
+   */
+  getPayer(request: Request): string | undefined {
+    return this.verifiedPayments.get(request)?.payer;
+  }
+
+  /**
+   * Get the full payment context for a verified payment request.
+   * Available after `verify()` succeeds and before `settle()` is called.
+   */
+  getPaymentContext(request: Request): Readonly<PaymentContext> | undefined {
+    return this.verifiedPayments.get(request);
+  }
+
+  // ── x402 Lifecycle Hooks ───────────────────────────────────────────
+
+  /** Register a hook to run before payment verification. Return `{ abort: true, reason }` to reject. */
+  onBeforeVerify(hook: BeforeVerifyHook): this {
+    this.resourceServer.onBeforeVerify(hook);
+    return this;
+  }
+
+  /** Register a hook to run after successful payment verification. */
+  onAfterVerify(hook: AfterVerifyHook): this {
+    this.resourceServer.onAfterVerify(hook);
+    return this;
+  }
+
+  /** Register a hook to run when payment verification fails. Return `{ recovered: true, result }` to recover. */
+  onVerifyFailure(hook: OnVerifyFailureHook): this {
+    this.resourceServer.onVerifyFailure(hook);
+    return this;
+  }
+
+  /** Register a hook to run before payment settlement. Return `{ abort: true, reason }` to reject. */
+  onBeforeSettle(hook: BeforeSettleHook): this {
+    this.resourceServer.onBeforeSettle(hook);
+    return this;
+  }
+
+  /** Register a hook to run after successful payment settlement. */
+  onAfterSettle(hook: AfterSettleHook): this {
+    this.resourceServer.onAfterSettle(hook);
+    return this;
+  }
+
+  /** Register a hook to run when payment settlement fails. Return `{ recovered: true, result }` to recover. */
+  onSettleFailure(hook: OnSettleFailureHook): this {
+    this.resourceServer.onSettleFailure(hook);
+    return this;
+  }
 }

package/app/plugin.ts

@@ -1,6 +1,26 @@
-import type { HttpMethod, RouteHandler, RouteEntry, Middleware } from "./types";
-import type { AcceptsX402 } from "../accepts";
-import type { PaymentGateway } from "./payment/payment";
+import type { HttpMethod, RouteHandler, RouteEntry, RouteOptions, Middleware } from "./types";
+import type {
+  PaymentGateway,
+  BeforeVerifyHook,
+  AfterVerifyHook,
+  OnVerifyFailureHook,
+  BeforeSettleHook,
+  AfterSettleHook,
+  OnSettleFailureHook,
+} from "./payment/payment";
+
+/**
+ * Scoped interface for registering x402 payment lifecycle hooks.
+ * Exposes only hook registration — not the full PaymentGateway.
+ */
+export interface PaymentHookContext {
+  onBeforeVerify(hook: BeforeVerifyHook): PaymentHookContext;
+  onAfterVerify(hook: AfterVerifyHook): PaymentHookContext;
+  onVerifyFailure(hook: OnVerifyFailureHook): PaymentHookContext;
+  onBeforeSettle(hook: BeforeSettleHook): PaymentHookContext;
+  onAfterSettle(hook: AfterSettleHook): PaymentHookContext;
+  onSettleFailure(hook: OnSettleFailureHook): PaymentHookContext;
+}
 
 /**
  * Scoped context passed to {@link BasePlugin.register}.
@@ -14,9 +34,11 @@ import type { PaymentGateway } from "./payment/payment";
  */
 export interface RegisterContext {
   /** Register a route on the application. Automatically tracked in `plugin.registeredRoutes`. */
-  route(method: HttpMethod, path: string, handler: RouteHandler, options?: { payment?: AcceptsX402 }): void;
+  route(method: HttpMethod, path: string, handler: RouteHandler, options?: RouteOptions): void;
   /** Append a middleware to the application's middleware chain. */
   use(middleware: Middleware): void;
+  /** Register hooks on the x402 payment lifecycle. Undefined when no facilitators configured. */
+  readonly paymentHooks?: PaymentHookContext;
 }
 
 /**

package/app/plugins/a2a.ts

@@ -25,7 +25,8 @@ export type Capabilities = z.infer<typeof CapabilitiesSchema>;
 
 export interface A2AAgentEntry {
   name?: string;
-  exports: { default: ToolLoopAgent; accepts?: Accepts; capabilities?: Capabilities };
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  exports: { default: ToolLoopAgent<never, any>; accepts?: Accepts; capabilities?: Capabilities };
   /** Optional task store override. Defaults to a per-agent InMemoryTaskStore for isolation. */
   taskStore?: TaskStore;
 }
@@ -250,7 +251,7 @@ export class A2APlugin extends BasePlugin {
         return Response.json(result);
       },
       {
-        payment: entry.exports.accepts.scheme === "exact" ? entry.exports.accepts : undefined,
+        payment: entry.exports.accepts,
       },
     );
   }

package/app/plugins/index-page/index.ts

@@ -3,6 +3,7 @@ import { z } from "zod";
 import { BasePlugin, type RegisterContext, type InitializeContext } from "../../plugin";
 import type { MCPPlugin } from "../mcp";
 import { renderHtml } from "./html";
+import { isAcceptsPaid } from "../../../accepts";
 
 export type AixyzConfigRuntime = ReturnType<typeof getAixyzConfigRuntime>;
 
@@ -141,7 +142,7 @@ export class IndexPagePlugin extends BasePlugin {
           protocol: "a2a",
           name,
           path: entry.path,
-          paid: entry.payment?.scheme === "exact",
+          paid: !!entry.payment, // only set for paid routes (free accepts filtered in AixyzApp.route())
         });
       }
     }
@@ -170,7 +171,7 @@ export class IndexPagePlugin extends BasePlugin {
           name: tool.name,
           path: "/mcp",
           description: tool.tool.description,
-          paid: tool.accepts?.scheme === "exact",
+          paid: tool.accepts ? isAcceptsPaid(tool.accepts) : false,
           inputSchema,
         });
       }

package/app/plugins/mcp.ts

@@ -1,12 +1,21 @@
+import { AsyncLocalStorage } from "node:async_hooks";
 import { type Tool } from "ai";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
 import { createPaymentWrapper } from "@x402/mcp";
 import { BasePlugin, type RegisterContext, type InitializeContext } from "../plugin";
 import type { Accepts } from "../../accepts";
-import { AcceptsScheme } from "../../accepts";
+import { AcceptsScheme, isAcceptsPaid, normalizeAcceptsX402 } from "../../accepts";
 import { getAixyzConfig, getAixyzConfigRuntime } from "../../config";
 import { Network } from "@x402/core/types";
+import { ExactEvmScheme } from "@x402/evm/exact/server";
+import type { SessionPlugin } from "./session/index";
+
+/**
+ * AsyncLocalStorage to pass the MCP-level payer address from the
+ * onAfterVerify hook to the tool handler within the same async context.
+ */
+const mcpPayerStorage = new AsyncLocalStorage<{ payer?: string }>();
 
 /**
  * MCP (Model Context Protocol) plugin. Collects tools and exposes them
@@ -20,6 +29,7 @@ export class MCPPlugin extends BasePlugin {
   readonly name = "mcp";
   readonly registeredTools: Array<{ name: string; tool: Tool; accepts?: Accepts }> = [];
   private paymentWrappers = new Map<string, (handler: any) => any>();
+  private sessionPlugin?: SessionPlugin;
 
   constructor(private tools: Array<{ name: string; exports: { default: Tool; accepts?: Accepts } }>) {
     super();
@@ -30,22 +40,44 @@ export class MCPPlugin extends BasePlugin {
     const mcpServer = new McpServer({ name: config.name, version: config.version }, { capabilities: { tools: {} } });
 
     for (const { name, tool } of this.registeredTools) {
+      const sessionPlugin = this.sessionPlugin;
       const handler = async (args: Record<string, unknown>) => {
-        try {
-          const result = await tool.execute!(args, { toolCallId: name, messages: [] });
-          const text = typeof result === "string" ? result : JSON.stringify(result, null, 2);
-          return { content: [{ type: "text" as const, text }] };
-        } catch (error) {
-          const text = error instanceof Error ? error.message : "Unknown error";
-          return { content: [{ type: "text" as const, text: `Error: ${text}` }], isError: true };
+        const execute = async () => {
+          try {
+            const result = await tool.execute!(args, { toolCallId: name, messages: [] });
+            const text = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+            return { content: [{ type: "text" as const, text }] };
+          } catch (error) {
+            console.error(`[mcp] Tool "${name}" failed:`, error);
+            const text = error instanceof Error ? error.message : "Unknown error";
+            return { content: [{ type: "text" as const, text: `Error: ${text}` }], isError: true };
+          }
+        };
+
+        // If a payer was captured from MCP-level payment, run the tool
+        // within a session context so getSession() works.
+        const payer = mcpPayerStorage.getStore()?.payer;
+        if (payer && sessionPlugin) {
+          return sessionPlugin.runWithPayer(payer, execute);
         }
+        return execute();
       };
 
       const wrapper = this.paymentWrappers.get(name);
+      let registeredHandler: (args: any, extra?: any) => any;
+      if (wrapper) {
+        const wrapped = wrapper(handler);
+        // Wrap the payment wrapper call in mcpPayerStorage.run() so the
+        // onAfterVerify hook and handler share the same async context.
+        registeredHandler = (args: any, extra: any) =>
+          mcpPayerStorage.run({ payer: undefined }, () => wrapped(args, extra));
+      } else {
+        registeredHandler = handler;
+      }
       mcpServer.registerTool(
         name,
         { description: tool.description, inputSchema: tool.inputSchema as any },
-        wrapper ? wrapper(handler) : handler,
+        registeredHandler,
       );
     }
 
@@ -79,25 +111,60 @@ export class MCPPlugin extends BasePlugin {
   }
 
   async initialize(ctx: InitializeContext): Promise<void> {
+    this.sessionPlugin = ctx.getPlugin<SessionPlugin>("session");
+
     if (!ctx.payment) return;
 
     const config = getAixyzConfig();
     const resourceServer = ctx.payment.resourceServer;
+    const defaultNetwork = (config.x402.network as Network) ?? ("eip155:8453" as Network);
+
+    // MCP payment operates via @x402/mcp wrappers independently of the HTTP payment
+    // middleware (PaymentGateway), so network schemes must be registered here separately.
+    // The default network is already registered by PaymentGateway.initialize() on the
+    // shared resourceServer — seed the set so we skip re-registering it.
+    const registeredNetworks = new Set<string>([defaultNetwork]);
+    for (const { accepts } of this.registeredTools) {
+      if (!accepts || !isAcceptsPaid(accepts)) continue;
+      for (const a of normalizeAcceptsX402(accepts)) {
+        const network = a.network ?? defaultNetwork;
+        if (!registeredNetworks.has(network)) {
+          registeredNetworks.add(network);
+          resourceServer.register(network as Network, new ExactEvmScheme());
+        }
+      }
+    }
 
-    for (const { name, accepts } of this.registeredTools) {
-      if (accepts?.scheme !== "exact") continue;
+    // Capture payer from MCP-level payment verification for session integration.
+    // This hook is global (fires for all verifications, including HTTP-level), but
+    // only writes when mcpPayerStorage has an active context — which only happens
+    // inside MCP tool calls wrapped by mcpPayerStorage.run() below.
+    ctx.payment.onAfterVerify(async (context) => {
+      const store = mcpPayerStorage.getStore();
+      if (store && context.result.payer) {
+        store.payer = context.result.payer;
+      }
+    });
 
-      const reqs = await resourceServer.buildPaymentRequirements({
-        scheme: accepts.scheme,
-        payTo: accepts.payTo ?? config.x402.payTo,
-        price: accepts.price,
-        network: (accepts.network as Network) ?? (config.x402.network as Network),
-      });
+    for (const { name, accepts } of this.registeredTools) {
+      if (!accepts || !isAcceptsPaid(accepts)) continue;
+
+      const items = normalizeAcceptsX402(accepts);
+      const allReqs: Awaited<ReturnType<typeof resourceServer.buildPaymentRequirements>> = [];
+      for (const a of items) {
+        const reqs = await resourceServer.buildPaymentRequirements({
+          scheme: a.scheme,
+          payTo: a.payTo ?? config.x402.payTo,
+          price: a.price,
+          network: (a.network as Network) ?? defaultNetwork,
+        });
+        allReqs.push(...reqs);
+      }
 
       this.paymentWrappers.set(
         name,
         createPaymentWrapper(resourceServer, {
-          accepts: reqs,
+          accepts: allReqs,
           resource: { url: `mcp://tool/${name}` },
         }),
       );