@coinbase/agentkit 0.8.1 → 0.9.0

package/dist/action-providers/x402/x402ActionProvider.d.ts

@@ -0,0 +1,55 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { Network } from "../../network";
+import { HttpRequestSchema, RetryWithX402Schema, DirectX402RequestSchema } from "./schemas";
+import { EvmWalletProvider } from "../../wallet-providers";
+/**
+ * X402ActionProvider provides actions for making HTTP requests, with optional x402 payment handling.
+ */
+export declare class X402ActionProvider extends ActionProvider<EvmWalletProvider> {
+    /**
+     * Creates a new instance of X402ActionProvider.
+     * Initializes the provider with x402 capabilities.
+     */
+    constructor();
+    /**
+     * Makes a basic HTTP request to an API endpoint.
+     *
+     * @param walletProvider - The wallet provider to use for potential payments
+     * @param args - The request parameters including URL, method, headers, and body
+     * @returns A JSON string containing the response or error details
+     */
+    makeHttpRequest(walletProvider: EvmWalletProvider, args: z.infer<typeof HttpRequestSchema>): Promise<string>;
+    /**
+     * Retries a request with x402 payment after receiving a 402 response.
+     *
+     * @param walletProvider - The wallet provider to use for making the payment
+     * @param args - The request parameters including URL, method, headers, body, and payment option
+     * @returns A JSON string containing the response with payment details or error information
+     */
+    retryWithX402(walletProvider: EvmWalletProvider, args: z.infer<typeof RetryWithX402Schema>): Promise<string>;
+    /**
+     * Makes an HTTP request with automatic x402 payment handling.
+     *
+     * @param walletProvider - The wallet provider to use for automatic payments
+     * @param args - The request parameters including URL, method, headers, and body
+     * @returns A JSON string containing the response with optional payment details or error information
+     */
+    makeHttpRequestWithX402(walletProvider: EvmWalletProvider, args: z.infer<typeof DirectX402RequestSchema>): Promise<string>;
+    /**
+     * Checks if the action provider supports the given network.
+     *
+     * @param network - The network to check support for
+     * @returns True if the network is supported, false otherwise
+     */
+    supportsNetwork: (network: Network) => boolean;
+    /**
+     * Helper method to handle HTTP errors consistently.
+     *
+     * @param error - The axios error to handle
+     * @param url - The URL that was being accessed when the error occurred
+     * @returns A JSON string containing formatted error details
+     */
+    private handleHttpError;
+}
+export declare const x402ActionProvider: () => X402ActionProvider;

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

@@ -0,0 +1,288 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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");
+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 SUPPORTED_NETWORKS = ["base-mainnet", "base-sepolia"];
+/**
+ * X402ActionProvider provides actions for making HTTP requests, with optional x402 payment handling.
+ */
+class X402ActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Creates a new instance of X402ActionProvider.
+     * Initializes the provider with x402 capabilities.
+     */
+    constructor() {
+        super("x402", []);
+        /**
+         * Checks if the action provider supports the given network.
+         *
+         * @param network - The network to check support for
+         * @returns True if the network is supported, false otherwise
+         */
+        this.supportsNetwork = (network) => network.protocolFamily === "evm" && SUPPORTED_NETWORKS.includes(network.networkId);
+    }
+    /**
+     * Makes a basic HTTP request to an API endpoint.
+     *
+     * @param walletProvider - The wallet provider to use for potential payments
+     * @param args - The request parameters including URL, method, headers, and body
+     * @returns A JSON string containing the response or error details
+     */
+    async makeHttpRequest(walletProvider, args) {
+        try {
+            const response = await axios_1.default.request({
+                url: args.url,
+                method: args.method ?? "GET",
+                headers: args.headers ?? undefined,
+                data: args.body,
+                validateStatus: status => status === 402 || (status >= 200 && status < 300),
+            });
+            if (response.status !== 402) {
+                return JSON.stringify({
+                    success: true,
+                    url: args.url,
+                    method: args.method,
+                    status: response.status,
+                    data: response.data,
+                }, null, 2);
+            }
+            return JSON.stringify({
+                status: "error_402_payment_required",
+                acceptablePaymentOptions: response.data.accepts,
+                nextSteps: [
+                    "Inform the user that the requested server replied with a 402 Payment Required response.",
+                    `The payment options are: ${response.data.accepts.map(option => `${option.asset} ${option.maxAmountRequired} ${option.network}`).join(", ")}`,
+                    "Ask the user if they want to retry the request with payment.",
+                    `Use retry_http_request_with_x402 to retry the request with payment.`,
+                ],
+            });
+        }
+        catch (error) {
+            return this.handleHttpError(error, args.url);
+        }
+    }
+    /**
+     * Retries a request with x402 payment after receiving a 402 response.
+     *
+     * @param walletProvider - The wallet provider to use for making the payment
+     * @param args - The request parameters including URL, method, headers, body, and payment option
+     * @returns A JSON string containing the response with payment details or error information
+     */
+    async retryWithX402(walletProvider, args) {
+        try {
+            // Make the request with payment handling
+            const account = 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;
+                }
+                paymentRequirements = accepts.find(accept => accept.scheme === scheme &&
+                    accept.network === network &&
+                    accept.maxAmountRequired <= maxAmountRequired &&
+                    accept.asset === asset);
+                if (paymentRequirements) {
+                    return paymentRequirements;
+                }
+                return accepts[0];
+            };
+            const api = (0, x402_axios_1.withPaymentInterceptor)(axios_1.default.create({}), 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;
+            return JSON.stringify({
+                status: "success",
+                data: response.data,
+                message: "Request completed successfully with payment",
+                details: {
+                    url: args.url,
+                    method: args.method,
+                    paymentUsed: {
+                        network: args.selectedPaymentOption.network,
+                        asset: args.selectedPaymentOption.asset,
+                        amount: args.selectedPaymentOption.maxAmountRequired,
+                    },
+                    paymentProof: paymentProof
+                        ? {
+                            transaction: paymentProof.transaction,
+                            network: paymentProof.network,
+                            payer: paymentProof.payer,
+                        }
+                        : null,
+                },
+            });
+        }
+        catch (error) {
+            return this.handleHttpError(error, args.url);
+        }
+    }
+    /**
+     * Makes an HTTP request with automatic x402 payment handling.
+     *
+     * @param walletProvider - The wallet provider to use for automatic payments
+     * @param args - The request parameters including URL, method, headers, and body
+     * @returns A JSON string containing the response with optional payment details or error information
+     */
+    async makeHttpRequestWithX402(walletProvider, args) {
+        try {
+            const account = walletProvider.toSigner();
+            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,
+            });
+            // Check for payment proof
+            const paymentProof = response.headers["x-payment-response"]
+                ? (0, x402_axios_1.decodeXPaymentResponse)(response.headers["x-payment-response"])
+                : null;
+            return JSON.stringify({
+                success: true,
+                message: "Request completed successfully (payment handled automatically if required)",
+                url: args.url,
+                method: args.method,
+                status: response.status,
+                data: response.data,
+                paymentProof: paymentProof
+                    ? {
+                        transaction: paymentProof.transaction,
+                        network: paymentProof.network,
+                        payer: paymentProof.payer,
+                    }
+                    : null,
+            }, null, 2);
+        }
+        catch (error) {
+            return this.handleHttpError(error, args.url);
+        }
+    }
+    /**
+     * Helper method to handle HTTP errors consistently.
+     *
+     * @param error - The axios error to handle
+     * @param url - The URL that was being accessed when the error occurred
+     * @returns A JSON string containing formatted error details
+     */
+    handleHttpError(error, url) {
+        if (error.response) {
+            return JSON.stringify({
+                error: true,
+                message: `HTTP ${error.response.status} error when accessing ${url}`,
+                details: error.response.data?.error || error.response.statusText,
+                suggestion: "Check if the URL is correct and the API is available.",
+            }, null, 2);
+        }
+        if (error.request) {
+            return JSON.stringify({
+                error: true,
+                message: `Network error when accessing ${url}`,
+                details: error.message,
+                suggestion: "Check your internet connection and verify the API endpoint is accessible.",
+            }, null, 2);
+        }
+        return JSON.stringify({
+            error: true,
+            message: `Error making request to ${url}`,
+            details: error.message,
+            suggestion: "Please check the request parameters and try again.",
+        }, null, 2);
+    }
+}
+exports.X402ActionProvider = X402ActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "make_http_request",
+        description: `
+Makes a basic HTTP request to an API endpoint. If the endpoint requires payment (returns 402),
+it will return payment details that can be used with retry_http_request_with_x402.
+
+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.`,
+        schema: schemas_1.HttpRequestSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], X402ActionProvider.prototype, "makeHttpRequest", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "retry_http_request_with_x402",
+        description: `
+Retries an HTTP request with x402 payment after receiving a 402 Payment Required response.
+This should be used after make_http_request returns a 402 response.
+
+EXAMPLE WORKFLOW:
+1. First call make_http_request("http://localhost:3000/protected")
+2. If you get a 402 response, use this action to retry with payment
+3. Pass the entire original response to this action
+
+DO NOT use this action directly without first trying make_http_request!`,
+        schema: schemas_1.RetryWithX402Schema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], X402ActionProvider.prototype, "retryWithX402", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "make_http_request_with_x402",
+        description: `
+⚠️ 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:
+1. First try make_http_request
+2. Then use retry_http_request_with_x402 if payment is required
+
+This action combines both steps into one, which means:
+- No chance to review payment details before paying
+- No confirmation step
+- Automatic payment processing
+
+EXAMPLES:
+- Production: make_http_request_with_x402("https://api.example.com/data")
+- Local dev: make_http_request_with_x402("http://localhost:3000/protected")
+
+Unless specifically instructed otherwise, prefer the two-step approach with make_http_request first.`,
+        schema: schemas_1.DirectX402RequestSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], X402ActionProvider.prototype, "makeHttpRequestWithX402", null);
+const x402ActionProvider = () => new X402ActionProvider();
+exports.x402ActionProvider = x402ActionProvider;

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

@@ -0,0 +1,322 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const x402ActionProvider_1 = require("./x402ActionProvider");
+const axios_1 = __importDefault(require("axios"));
+const x402axios = __importStar(require("x402-axios"));
+// Mock modules
+jest.mock("axios");
+jest.mock("x402-axios");
+// Create mock functions
+const mockRequest = jest.fn();
+// Create a complete mock axios instance
+const mockAxiosInstance = {
+    request: mockRequest,
+    get: jest.fn(),
+    delete: jest.fn(),
+    head: jest.fn(),
+    options: jest.fn(),
+    post: jest.fn(),
+    put: jest.fn(),
+    patch: jest.fn(),
+    getUri: jest.fn(),
+    defaults: {},
+    interceptors: {
+        request: { use: jest.fn(), eject: jest.fn(), clear: jest.fn() },
+        response: { use: jest.fn(), eject: jest.fn(), clear: jest.fn() },
+    },
+};
+// Create a complete mock axios static
+const mockAxios = {
+    create: jest.fn().mockReturnValue(mockAxiosInstance),
+    request: mockRequest,
+    get: jest.fn(),
+    delete: jest.fn(),
+    head: jest.fn(),
+    options: jest.fn(),
+    post: jest.fn(),
+    put: jest.fn(),
+    patch: jest.fn(),
+    all: jest.fn(),
+    spread: jest.fn(),
+    isAxiosError: jest.fn(),
+    isCancel: jest.fn(),
+    CancelToken: {
+        source: jest.fn(),
+    },
+    VERSION: "1.x",
+};
+const mockWithPaymentInterceptor = jest.fn().mockReturnValue(mockAxiosInstance);
+const mockDecodeXPaymentResponse = jest.fn();
+// Override the mocked modules
+axios_1.default.create = mockAxios.create;
+axios_1.default.request = mockRequest;
+axios_1.default.isAxiosError = mockAxios.isAxiosError;
+// Mock x402-axios functions
+jest.mocked(x402axios.withPaymentInterceptor).mockImplementation(mockWithPaymentInterceptor);
+jest.mocked(x402axios.decodeXPaymentResponse).mockImplementation(mockDecodeXPaymentResponse);
+// Mock wallet provider
+const mockWalletProvider = {
+    toSigner: jest.fn().mockReturnValue("mock-signer"),
+};
+// Sample responses based on real examples
+const MOCK_PAYMENT_INFO_RESPONSE = {
+    paymentRequired: true,
+    url: "https://www.x402.org/protected",
+    status: 402,
+    data: {
+        x402Version: 1,
+        error: "X-PAYMENT header is required",
+        accepts: [
+            {
+                scheme: "exact",
+                network: "base-sepolia",
+                maxAmountRequired: "10000",
+                resource: "https://www.x402.org/protected",
+                description: "Access to protected content",
+                mimeType: "application/json",
+                payTo: "0x209693Bc6afc0C5328bA36FaF03C514EF312287C",
+                maxTimeoutSeconds: 300,
+                asset: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+                extra: {
+                    name: "USDC",
+                    version: "2",
+                },
+            },
+        ],
+    },
+};
+const MOCK_PAYMENT_RESPONSE = {
+    success: true,
+    transaction: "0xcbc385789d3744b52af5106c32809534f64adcbe097e050ec03d6b53fed5d305",
+    network: "base-sepolia",
+    payer: "0xa8c1a5D3C372C65c04f91f87a43F549619A9483f",
+};
+describe("X402ActionProvider", () => {
+    let provider;
+    beforeEach(() => {
+        provider = new x402ActionProvider_1.X402ActionProvider();
+        jest.clearAllMocks();
+        // Setup mocks
+        mockAxios.create.mockReturnValue(mockAxiosInstance);
+        mockWithPaymentInterceptor.mockReturnValue(mockAxiosInstance);
+        // Setup axios.isAxiosError mock
+        jest
+            .mocked(axios_1.default.isAxiosError)
+            .mockImplementation((error) => Boolean(error &&
+            typeof error === "object" &&
+            ("isAxiosError" in error || "response" in error || "request" in error)));
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    describe("supportsNetwork", () => {
+        it("should support base-mainnet", () => {
+            const network = { protocolFamily: "evm", networkId: "base-mainnet" };
+            expect(provider.supportsNetwork(network)).toBe(true);
+        });
+        it("should support base-sepolia", () => {
+            const network = { protocolFamily: "evm", networkId: "base-sepolia" };
+            expect(provider.supportsNetwork(network)).toBe(true);
+        });
+        it("should not support unsupported EVM networks", () => {
+            const network = { protocolFamily: "evm", networkId: "ethereum" };
+            expect(provider.supportsNetwork(network)).toBe(false);
+        });
+        it("should not support non-EVM networks", () => {
+            const network = { protocolFamily: "solana", networkId: "mainnet" };
+            expect(provider.supportsNetwork(network)).toBe(false);
+        });
+    });
+    describe("makeHttpRequest", () => {
+        it("should handle successful non-payment requests", async () => {
+            mockRequest.mockResolvedValue({
+                status: 200,
+                data: { message: "Success" },
+                headers: {},
+                config: {},
+            });
+            const result = await provider.makeHttpRequest(mockWalletProvider, {
+                url: "https://api.example.com/free",
+                method: "GET",
+            });
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.success).toBe(true);
+            expect(parsedResult.status).toBe(200);
+            expect(parsedResult.data).toEqual({ message: "Success" });
+        });
+        it("should handle 402 responses with payment options", async () => {
+            mockRequest.mockResolvedValue({
+                status: 402,
+                data: MOCK_PAYMENT_INFO_RESPONSE.data,
+                headers: {},
+                config: {},
+            });
+            const result = await provider.makeHttpRequest(mockWalletProvider, {
+                url: "https://www.x402.org/protected",
+                method: "GET",
+            });
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.status).toBe("error_402_payment_required");
+            expect(parsedResult.acceptablePaymentOptions).toEqual(MOCK_PAYMENT_INFO_RESPONSE.data.accepts);
+            expect(parsedResult.nextSteps).toBeDefined();
+        });
+        it("should handle network errors", async () => {
+            const error = new Error("Network error");
+            error.isAxiosError = true;
+            error.request = {};
+            mockRequest.mockRejectedValue(error);
+            const result = await provider.makeHttpRequest(mockWalletProvider, {
+                url: "https://api.example.com/endpoint",
+                method: "GET",
+            });
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.error).toBe(true);
+            expect(parsedResult.message).toContain("Network error");
+        });
+    });
+    describe("retryHttpRequestWithX402", () => {
+        it("should successfully retry with payment", async () => {
+            mockDecodeXPaymentResponse.mockReturnValue(MOCK_PAYMENT_RESPONSE);
+            mockRequest.mockResolvedValue({
+                status: 200,
+                statusText: "OK",
+                data: { message: "Paid content" },
+                headers: {
+                    "x-payment-response": "encoded-payment-data",
+                },
+                config: {},
+            });
+            const result = await provider.retryWithX402(mockWalletProvider, {
+                url: "https://www.x402.org/protected",
+                method: "GET",
+                selectedPaymentOption: {
+                    scheme: "exact",
+                    network: "base-sepolia",
+                    maxAmountRequired: "10000",
+                    asset: "0x456",
+                },
+            });
+            // Update expectation to accept the payment selector function
+            expect(mockWithPaymentInterceptor).toHaveBeenCalledWith(mockAxiosInstance, "mock-signer", expect.any(Function));
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.status).toBe("success");
+            expect(parsedResult.details.paymentProof).toEqual({
+                transaction: MOCK_PAYMENT_RESPONSE.transaction,
+                network: MOCK_PAYMENT_RESPONSE.network,
+                payer: MOCK_PAYMENT_RESPONSE.payer,
+            });
+        });
+        it("should handle network errors during payment", async () => {
+            const error = new Error("Network error");
+            error.isAxiosError = true;
+            error.request = {};
+            mockRequest.mockRejectedValue(error);
+            const result = await provider.retryWithX402(mockWalletProvider, {
+                url: "https://www.x402.org/protected",
+                method: "GET",
+                selectedPaymentOption: {
+                    scheme: "exact",
+                    network: "base-sepolia",
+                    maxAmountRequired: "10000",
+                    asset: "0x456",
+                },
+            });
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.error).toBe(true);
+            expect(parsedResult.message).toContain("Network error");
+        });
+    });
+    describe("makeHttpRequestWithX402", () => {
+        it("should handle successful direct payment requests", async () => {
+            mockDecodeXPaymentResponse.mockReturnValue(MOCK_PAYMENT_RESPONSE);
+            mockRequest.mockResolvedValue({
+                status: 200,
+                statusText: "OK",
+                data: { message: "Paid content" },
+                headers: {
+                    "x-payment-response": "encoded-payment-data",
+                },
+                config: {},
+            });
+            const result = await provider.makeHttpRequestWithX402(mockWalletProvider, {
+                url: "https://www.x402.org/protected",
+                method: "GET",
+            });
+            expect(mockWithPaymentInterceptor).toHaveBeenCalledWith(mockAxiosInstance, "mock-signer");
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.success).toBe(true);
+            expect(parsedResult.data).toEqual({ message: "Paid content" });
+            expect(parsedResult.paymentProof).toEqual({
+                transaction: MOCK_PAYMENT_RESPONSE.transaction,
+                network: MOCK_PAYMENT_RESPONSE.network,
+                payer: MOCK_PAYMENT_RESPONSE.payer,
+            });
+        });
+        it("should handle successful non-payment requests", async () => {
+            mockRequest.mockResolvedValue({
+                status: 200,
+                statusText: "OK",
+                data: { message: "Free content" },
+                headers: {},
+                config: {},
+            });
+            const result = await provider.makeHttpRequestWithX402(mockWalletProvider, {
+                url: "https://api.example.com/free",
+                method: "GET",
+            });
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.success).toBe(true);
+            expect(parsedResult.data).toEqual({ message: "Free content" });
+            expect(parsedResult.paymentProof).toBeNull();
+        });
+        it("should handle network errors", async () => {
+            const error = new Error("Network error");
+            error.isAxiosError = true;
+            error.request = {};
+            mockRequest.mockRejectedValue(error);
+            const result = await provider.makeHttpRequestWithX402(mockWalletProvider, {
+                url: "https://api.example.com/endpoint",
+                method: "GET",
+            });
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.error).toBe(true);
+            expect(parsedResult.message).toContain("Network error");
+        });
+    });
+});

package/dist/agentkit.d.ts

@@ -6,6 +6,7 @@ import { Action, ActionProvider } from "./action-providers";
 export type AgentKitOptions = {
     cdpApiKeyId?: string;
     cdpApiKeySecret?: string;
+    cdpWalletSecret?: string;
     walletProvider?: WalletProvider;
     actionProviders?: ActionProvider[];
 };