@coinbase/agentkit 0.10.3 → 0.10.4

package/dist/action-providers/x402/x402ActionProvider.js

@@ -8,9 +8,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.x402ActionProvider = exports.X402ActionProvider = void 0;
 const zod_1 = require("zod");
@@ -18,12 +15,11 @@ const actionProvider_1 = require("../actionProvider");
 const actionDecorator_1 = require("../actionDecorator");
 const schemas_1 = require("./schemas");
 const wallet_providers_1 = require("../../wallet-providers");
-const axios_1 = __importDefault(require("axios"));
-const x402_axios_1 = require("x402-axios");
-const verify_1 = require("x402/verify");
-const x402_1 = require("@coinbase/x402");
+const fetch_1 = require("@x402/fetch");
+const client_1 = require("@x402/evm/exact/client");
+const client_2 = require("@x402/svm/exact/client");
 const utils_1 = require("./utils");
-const SUPPORTED_NETWORKS = ["base-mainnet", "base-sepolia", "solana-mainnet", "solana-devnet"];
+const constants_1 = require("./constants");
 /**
  * X402ActionProvider provides actions for making HTTP requests, with optional x402 payment handling.
  */
@@ -40,107 +36,50 @@ class X402ActionProvider extends actionProvider_1.ActionProvider {
          * @param network - The network to check support for
          * @returns True if the network is supported, false otherwise
          */
-        this.supportsNetwork = (network) => SUPPORTED_NETWORKS.includes(network.networkId);
+        this.supportsNetwork = (network) => constants_1.SUPPORTED_NETWORKS.includes(network.networkId);
     }
     /**
      * Discovers available x402 services with optional filtering.
      *
      * @param walletProvider - The wallet provider to use for network filtering
-     * @param args - Optional filters: maxUsdcPrice
+     * @param args - Optional filters: discoveryUrl, maxUsdcPrice
      * @returns JSON string with the list of services (filtered by network and description)
      */
     async discoverX402Services(walletProvider, args) {
         try {
-            const { list } = (0, verify_1.useFacilitator)(x402_1.facilitator);
-            const services = await list();
-            if (!services || !services.items) {
+            console.log("args", args);
+            const facilitatorUrl = (0, schemas_1.resolveFacilitatorUrl)(args.facilitator);
+            const discoveryUrl = facilitatorUrl + "/discovery/resources";
+            // Fetch all resources with pagination
+            const allResources = await (0, utils_1.fetchAllDiscoveryResources)(discoveryUrl);
+            if (allResources.length === 0) {
                 return JSON.stringify({
                     error: true,
                     message: "No services found",
                 });
             }
-            // Get the current wallet network
-            const walletNetwork = (0, utils_1.getX402Network)(walletProvider.getNetwork());
-            // Filter services by network, description, and optional USDC price
-            const hasValidMaxUsdcPrice = typeof args.maxUsdcPrice === "number" &&
-                Number.isFinite(args.maxUsdcPrice) &&
-                args.maxUsdcPrice > 0;
-            const filteredServices = services.items.filter(item => {
-                // Filter by network - only include services that accept the current wallet network
-                const accepts = Array.isArray(item.accepts) ? item.accepts : [];
-                const hasMatchingNetwork = accepts.some(req => req.network === walletNetwork);
-                // Filter out services with empty or default descriptions
-                const hasDescription = accepts.some(req => req.description &&
-                    req.description.trim() !== "" &&
-                    req.description.trim() !== "Access to protected content");
-                return hasMatchingNetwork && hasDescription;
-            });
-            // Apply USDC price filtering if maxUsdcPrice is provided (only consider USDC assets)
-            let priceFilteredServices = filteredServices;
-            if (hasValidMaxUsdcPrice) {
-                priceFilteredServices = [];
-                for (const item of filteredServices) {
-                    const accepts = Array.isArray(item.accepts) ? item.accepts : [];
-                    let shouldInclude = false;
-                    for (const req of accepts) {
-                        if (req.network === walletNetwork && req.asset && req.maxAmountRequired) {
-                            // Only consider USDC assets when maxUsdcPrice filter is applied
-                            if ((0, utils_1.isUsdcAsset)(req.asset, walletProvider)) {
-                                try {
-                                    const maxUsdcPriceAtomic = await (0, utils_1.convertWholeUnitsToAtomic)(args.maxUsdcPrice, req.asset, walletProvider);
-                                    if (maxUsdcPriceAtomic) {
-                                        const requirement = BigInt(req.maxAmountRequired);
-                                        const maxUsdcPriceAtomicBigInt = BigInt(maxUsdcPriceAtomic);
-                                        if (requirement <= maxUsdcPriceAtomicBigInt) {
-                                            shouldInclude = true;
-                                            break;
-                                        }
-                                    }
-                                }
-                                catch {
-                                    // If conversion fails, skip this requirement
-                                    continue;
-                                }
-                            }
-                        }
-                    }
-                    if (shouldInclude) {
-                        priceFilteredServices.push(item);
-                    }
-                }
+            // Get the wallet's network identifiers (both v1 and v2 formats)
+            const walletNetworks = (0, utils_1.getX402Networks)(walletProvider.getNetwork());
+            // Apply filter pipeline
+            let filteredResources = (0, utils_1.filterByNetwork)(allResources, walletNetworks);
+            filteredResources = (0, utils_1.filterByDescription)(filteredResources);
+            filteredResources = (0, utils_1.filterByX402Version)(filteredResources, args.x402Versions);
+            // Apply keyword filter if provided
+            if (args.keyword) {
+                filteredResources = (0, utils_1.filterByKeyword)(filteredResources, args.keyword);
             }
-            // Format the filtered services
-            const filtered = await Promise.all(priceFilteredServices.map(async (item) => {
-                const accepts = Array.isArray(item.accepts) ? item.accepts : [];
-                const matchingAccept = accepts.find(req => req.network === walletNetwork);
-                // Format amount if available
-                let formattedMaxAmount = matchingAccept?.maxAmountRequired;
-                if (matchingAccept?.maxAmountRequired && matchingAccept?.asset) {
-                    formattedMaxAmount = await (0, utils_1.formatPaymentOption)({
-                        asset: matchingAccept.asset,
-                        maxAmountRequired: matchingAccept.maxAmountRequired,
-                        network: matchingAccept.network,
-                    }, walletProvider);
-                }
-                return {
-                    resource: item.resource,
-                    description: matchingAccept?.description || "",
-                    cost: formattedMaxAmount,
-                    ...(matchingAccept?.outputSchema?.input && {
-                        input: matchingAccept.outputSchema.input,
-                    }),
-                    ...(matchingAccept?.outputSchema?.output && {
-                        output: matchingAccept.outputSchema.output,
-                    }),
-                    ...(item.metadata && item.metadata.length > 0 && { metadata: item.metadata }),
-                };
-            }));
+            // Apply price filter if maxUsdcPrice is provided
+            if (args.maxUsdcPrice !== undefined) {
+                filteredResources = await (0, utils_1.filterByMaxPrice)(filteredResources, args.maxUsdcPrice, walletProvider, walletNetworks);
+            }
+            // Format simplified output
+            const simplifiedResources = await (0, utils_1.formatSimplifiedResources)(filteredResources, walletNetworks, walletProvider);
             return JSON.stringify({
                 success: true,
-                walletNetwork,
-                total: services.items.length,
-                returned: filtered.length,
-                items: filtered,
+                services: simplifiedResources,
+                walletNetworks,
+                total: allResources.length,
+                returned: simplifiedResources.length,
             }, null, 2);
         }
         catch (error) {
@@ -161,42 +100,89 @@ class X402ActionProvider extends actionProvider_1.ActionProvider {
      */
     async makeHttpRequest(walletProvider, args) {
         try {
-            const response = await axios_1.default.request({
-                url: args.url,
-                method: args.method ?? "GET",
+            const finalUrl = (0, utils_1.buildUrlWithParams)(args.url, args.queryParams);
+            let method = args.method ?? "GET";
+            let canHaveBody = ["POST", "PUT", "PATCH"].includes(method);
+            let response = await fetch(finalUrl, {
+                method,
                 headers: args.headers ?? undefined,
-                data: args.body,
-                validateStatus: status => status === 402 || (status >= 200 && status < 300),
+                body: canHaveBody && args.body ? JSON.stringify(args.body) : undefined,
             });
+            // Retry with other http method for 404 status code
+            if (response.status === 404) {
+                method = method === "GET" ? "POST" : "GET";
+                canHaveBody = ["POST", "PUT", "PATCH"].includes(method);
+                response = await fetch(finalUrl, {
+                    method,
+                    headers: args.headers ?? undefined,
+                    body: canHaveBody && args.body ? JSON.stringify(args.body) : undefined,
+                });
+            }
             if (response.status !== 402) {
+                const data = await this.parseResponseData(response);
                 return JSON.stringify({
                     success: true,
-                    url: args.url,
-                    method: args.method,
+                    url: finalUrl,
+                    method,
                     status: response.status,
-                    data: response.data,
+                    data,
                 }, null, 2);
             }
-            // Check if wallet network matches any available payment options
-            const walletNetwork = (0, utils_1.getX402Network)(walletProvider.getNetwork());
-            const availableNetworks = response.data.accepts.map(option => option.network);
-            const hasMatchingNetwork = availableNetworks.includes(walletNetwork);
-            let paymentOptionsText = `The wallet network ${walletNetwork} does not match any available payment options (${availableNetworks.join(", ")}).`;
-            // Format payment options for matching networks
+            // Handle 402 Payment Required
+            // v2 sends requirements in PAYMENT-REQUIRED header; v1 sends in body
+            const walletNetworks = (0, utils_1.getX402Networks)(walletProvider.getNetwork());
+            let acceptsArray = [];
+            let paymentData = {};
+            // Check for v2 header-based payment requirements
+            const paymentRequiredHeader = response.headers.get("payment-required");
+            if (paymentRequiredHeader) {
+                try {
+                    const decoded = JSON.parse(atob(paymentRequiredHeader));
+                    acceptsArray = decoded.accepts ?? [];
+                    paymentData = decoded;
+                }
+                catch {
+                    // Header parsing failed, fall back to body
+                }
+            }
+            // Fall back to v1 body-based requirements if header not present or empty
+            if (acceptsArray.length === 0) {
+                paymentData = await response.json();
+                acceptsArray = paymentData.accepts ?? [];
+            }
+            const availableNetworks = acceptsArray.map(option => option.network);
+            const hasMatchingNetwork = availableNetworks.some((net) => walletNetworks.includes(net));
+            let paymentOptionsText = `The wallet networks ${walletNetworks.join(", ")} do not match any available payment options (${availableNetworks.join(", ")}).`;
             if (hasMatchingNetwork) {
-                const matchingOptions = response.data.accepts.filter(option => option.network === walletNetwork);
-                const formattedOptions = await Promise.all(matchingOptions.map(option => (0, utils_1.formatPaymentOption)(option, walletProvider)));
+                const matchingOptions = acceptsArray.filter(option => walletNetworks.includes(option.network));
+                const formattedOptions = await Promise.all(matchingOptions.map(option => (0, utils_1.formatPaymentOption)({
+                    asset: option.asset,
+                    maxAmountRequired: option.maxAmountRequired ?? option.amount ?? "0",
+                    network: option.network,
+                }, walletProvider)));
                 paymentOptionsText = `The payment options are: ${formattedOptions.join(", ")}`;
             }
+            // Extract discovery info from v2 response (description, mimeType, extensions)
+            const discoveryInfo = {};
+            if (paymentData.description)
+                discoveryInfo.description = paymentData.description;
+            if (paymentData.mimeType)
+                discoveryInfo.mimeType = paymentData.mimeType;
+            if (paymentData.extensions)
+                discoveryInfo.extensions = paymentData.extensions;
             return JSON.stringify({
                 status: "error_402_payment_required",
-                acceptablePaymentOptions: response.data.accepts,
+                acceptablePaymentOptions: acceptsArray,
+                ...(Object.keys(discoveryInfo).length > 0 && { discoveryInfo }),
                 nextSteps: [
                     "Inform the user that the requested server replied with a 402 Payment Required response.",
                     paymentOptionsText,
+                    "Include the description of the service in the response.",
+                    "IMPORTANT: Identify required or optional query or body parameters based on this response. If there are any, you must inform the user and request them to provide the values. Always suggest example values.",
+                    "CRITICAL: For POST/PUT/PATCH requests, you MUST use the 'body' parameter (NOT queryParams) to send data.",
                     hasMatchingNetwork ? "Ask the user if they want to retry the request with payment." : "",
                     hasMatchingNetwork
-                        ? `Use retry_http_request_with_x402 to retry the request with payment.`
+                        ? "Use retry_http_request_with_x402 to retry the request with payment. IMPORTANT: You must retry_http_request_with_x402 with the correct Http method. "
                         : "",
                 ],
             });
@@ -214,14 +200,15 @@ class X402ActionProvider extends actionProvider_1.ActionProvider {
      */
     async retryWithX402(walletProvider, args) {
         try {
+            console.log("args", args);
             // Check network compatibility before attempting payment
-            const walletNetwork = (0, utils_1.getX402Network)(walletProvider.getNetwork());
+            const walletNetworks = (0, utils_1.getX402Networks)(walletProvider.getNetwork());
             const selectedNetwork = args.selectedPaymentOption.network;
-            if (walletNetwork !== selectedNetwork) {
+            if (!walletNetworks.includes(selectedNetwork)) {
                 return JSON.stringify({
                     error: true,
                     message: "Network mismatch",
-                    details: `Wallet is on ${walletNetwork} but payment requires ${selectedNetwork}`,
+                    details: `Wallet is on ${walletNetworks.join(", ")} but payment requires ${selectedNetwork}`,
                 }, null, 2);
             }
             // Check if wallet provider is supported
@@ -232,58 +219,68 @@ class X402ActionProvider extends actionProvider_1.ActionProvider {
                     details: "Only SvmWalletProvider and EvmWalletProvider are supported",
                 }, null, 2);
             }
+            // Create x402 client with appropriate signer
+            const client = await this.createX402Client(walletProvider);
+            const fetchWithPayment = (0, fetch_1.wrapFetchWithPayment)(fetch, client);
+            // Build URL with query params and determine if body is allowed
+            const finalUrl = (0, utils_1.buildUrlWithParams)(args.url, args.queryParams);
+            const method = args.method ?? "GET";
+            const canHaveBody = ["POST", "PUT", "PATCH"].includes(method);
+            // Build headers, adding Content-Type for JSON body
+            const headers = { ...(args.headers ?? {}) };
+            if (canHaveBody && args.body) {
+                headers["Content-Type"] = "application/json";
+            }
             // Make the request with payment handling
-            const account = await walletProvider.toSigner();
-            const paymentSelector = (accepts) => {
-                const { scheme, network, maxAmountRequired, asset } = args.selectedPaymentOption;
-                let paymentRequirements = accepts.find(accept => accept.scheme === scheme &&
-                    accept.network === network &&
-                    accept.maxAmountRequired <= maxAmountRequired &&
-                    accept.asset === asset);
-                if (paymentRequirements) {
-                    return paymentRequirements;
+            const response = await fetchWithPayment(finalUrl, {
+                method,
+                headers,
+                body: canHaveBody && args.body ? JSON.stringify(args.body) : undefined,
+            });
+            const data = await this.parseResponseData(response);
+            // Check for payment proof in headers (v2: payment-response, v1: x-payment-response)
+            const paymentResponseHeader = response.headers.get("payment-response") ?? response.headers.get("x-payment-response");
+            let paymentProof = null;
+            if (paymentResponseHeader) {
+                try {
+                    paymentProof = JSON.parse(atob(paymentResponseHeader));
                 }
-                paymentRequirements = accepts.find(accept => accept.scheme === scheme &&
-                    accept.network === network &&
-                    accept.maxAmountRequired <= maxAmountRequired &&
-                    accept.asset === asset);
-                if (paymentRequirements) {
-                    return paymentRequirements;
+                catch {
+                    // If parsing fails, include raw header
+                    paymentProof = { raw: paymentResponseHeader };
                 }
-                return accepts[0];
-            };
-            const api = (0, x402_axios_1.withPaymentInterceptor)(axios_1.default.create({}), 
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            account, paymentSelector);
-            const response = await api.request({
-                url: args.url,
-                method: args.method ?? "GET",
-                headers: args.headers ?? undefined,
-                data: args.body,
-            });
-            // Check for payment proof
-            const paymentProof = response.headers["x-payment-response"]
-                ? (0, x402_axios_1.decodeXPaymentResponse)(response.headers["x-payment-response"])
-                : null;
+            }
+            // Get the amount used (supports both v1 and v2 formats)
+            const amountUsed = args.selectedPaymentOption.maxAmountRequired ??
+                args.selectedPaymentOption.amount ??
+                args.selectedPaymentOption.price;
+            // Check if the response was successful
+            // Payment is only settled on 200 status
+            if (response.status !== 200) {
+                return JSON.stringify({
+                    status: "error",
+                    message: `Request failed with status ${response.status}. Payment was not settled.`,
+                    httpStatus: response.status,
+                    data,
+                    details: {
+                        url: finalUrl,
+                        method,
+                    },
+                });
+            }
             return JSON.stringify({
                 status: "success",
-                data: response.data,
+                data,
                 message: "Request completed successfully with payment",
                 details: {
-                    url: args.url,
-                    method: args.method,
+                    url: finalUrl,
+                    method,
                     paymentUsed: {
                         network: args.selectedPaymentOption.network,
                         asset: args.selectedPaymentOption.asset,
-                        amount: args.selectedPaymentOption.maxAmountRequired,
+                        amount: amountUsed,
                     },
-                    paymentProof: paymentProof
-                        ? {
-                            transaction: paymentProof.transaction,
-                            network: paymentProof.network,
-                            payer: paymentProof.payer,
-                        }
-                        : null,
+                    paymentProof,
                 },
             });
         }
@@ -307,39 +304,93 @@ class X402ActionProvider extends actionProvider_1.ActionProvider {
                     details: "Only SvmWalletProvider and EvmWalletProvider are supported",
                 }, null, 2);
             }
-            const account = await walletProvider.toSigner();
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const api = (0, x402_axios_1.withPaymentInterceptor)(axios_1.default.create({}), account);
-            const response = await api.request({
-                url: args.url,
-                method: args.method ?? "GET",
-                headers: args.headers ?? undefined,
-                data: args.body,
+            // Create x402 client with appropriate signer
+            const client = await this.createX402Client(walletProvider);
+            const fetchWithPayment = (0, fetch_1.wrapFetchWithPayment)(fetch, client);
+            // Build URL with query params and determine if body is allowed
+            const finalUrl = (0, utils_1.buildUrlWithParams)(args.url, args.queryParams);
+            const method = args.method ?? "GET";
+            const canHaveBody = ["POST", "PUT", "PATCH"].includes(method);
+            // Build headers, adding Content-Type for JSON body
+            const headers = { ...(args.headers ?? {}) };
+            if (canHaveBody && args.body) {
+                headers["Content-Type"] = "application/json";
+            }
+            const response = await fetchWithPayment(finalUrl, {
+                method,
+                headers,
+                body: canHaveBody && args.body ? JSON.stringify(args.body) : undefined,
             });
-            // Check for payment proof
-            const paymentProof = response.headers["x-payment-response"]
-                ? (0, x402_axios_1.decodeXPaymentResponse)(response.headers["x-payment-response"])
-                : null;
+            const data = await this.parseResponseData(response);
+            // Check for payment proof in headers (v2: payment-response, v1: x-payment-response)
+            const paymentResponseHeader = response.headers.get("payment-response") ?? response.headers.get("x-payment-response");
+            let paymentProof = null;
+            if (paymentResponseHeader) {
+                try {
+                    paymentProof = JSON.parse(atob(paymentResponseHeader));
+                }
+                catch {
+                    // If parsing fails, include raw header
+                    paymentProof = { raw: paymentResponseHeader };
+                }
+            }
+            // Check if the response was successful
+            // Payment is only settled on 200 status
+            if (response.status !== 200) {
+                return JSON.stringify({
+                    success: false,
+                    message: `Request failed with status ${response.status}. Payment was not settled.`,
+                    url: finalUrl,
+                    method,
+                    status: response.status,
+                    data,
+                }, null, 2);
+            }
             return JSON.stringify({
                 success: true,
                 message: "Request completed successfully (payment handled automatically if required)",
-                url: args.url,
-                method: args.method,
+                url: finalUrl,
+                method,
                 status: response.status,
-                data: response.data,
-                paymentProof: paymentProof
-                    ? {
-                        transaction: paymentProof.transaction,
-                        network: paymentProof.network,
-                        payer: paymentProof.payer,
-                    }
-                    : null,
+                data,
+                paymentProof,
             }, null, 2);
         }
         catch (error) {
             return (0, utils_1.handleHttpError)(error, args.url);
         }
     }
+    /**
+     * Creates an x402 client configured for the given wallet provider.
+     *
+     * @param walletProvider - The wallet provider to configure the client for
+     * @returns Configured x402Client
+     */
+    async createX402Client(walletProvider) {
+        const client = new fetch_1.x402Client();
+        if (walletProvider instanceof wallet_providers_1.EvmWalletProvider) {
+            const signer = walletProvider.toSigner();
+            (0, client_1.registerExactEvmScheme)(client, { signer });
+        }
+        else if (walletProvider instanceof wallet_providers_1.SvmWalletProvider) {
+            const signer = await walletProvider.toSigner();
+            (0, client_2.registerExactSvmScheme)(client, { signer });
+        }
+        return client;
+    }
+    /**
+     * Parses response data based on content type.
+     *
+     * @param response - The fetch Response object
+     * @returns Parsed response data
+     */
+    async parseResponseData(response) {
+        const contentType = response.headers.get("content-type") ?? "";
+        if (contentType.includes("application/json")) {
+            return response.json();
+        }
+        return response.text();
+    }
 }
 exports.X402ActionProvider = X402ActionProvider;
 __decorate([
@@ -362,9 +413,9 @@ it will return payment details that can be used with retry_http_request_with_x40
 EXAMPLES:
 - Production API: make_http_request("https://api.example.com/weather")
 - Local development: make_http_request("http://localhost:3000/api/data")
-- Testing x402: make_http_request("http://localhost:3000/protected")
 
-If you receive a 402 Payment Required response, use retry_http_request_with_x402 to handle the payment.`,
+If you receive a 402 Payment Required response, use retry_http_request_with_x402 to handle the payment.
+`,
         schema: schemas_1.HttpRequestSchema,
     }),
     __metadata("design:type", Function),
@@ -394,7 +445,7 @@ __decorate([
     (0, actionDecorator_1.CreateAction)({
         name: "make_http_request_with_x402",
         description: `
-⚠️ WARNING: This action automatically handles payments without asking for confirmation!
+WARNING: This action automatically handles payments without asking for confirmation!
 Only use this when explicitly told to skip the confirmation flow.
 
 For most cases, you should: