@agentspend/sdk 0.3.7 → 0.3.9

package/dist/core/client.d.ts

@@ -0,0 +1,6 @@
+import type { AgentSpendOptions, ChargeOptions, ChargeResponse, PaywallOptions, PaywallRequest, PaywallResult } from "./types.js";
+export interface AgentSpendClient {
+    charge(cardId: string, opts: ChargeOptions): Promise<ChargeResponse>;
+    processPaywall(opts: PaywallOptions, request: PaywallRequest): Promise<PaywallResult>;
+}
+export declare function createAgentSpendClient(options: AgentSpendOptions): AgentSpendClient;

package/dist/core/client.js

@@ -0,0 +1,308 @@
+import { HTTPFacilitatorClient, x402ResourceServer } from "@x402/core/server";
+import { registerExactEvmScheme } from "@x402/evm/exact/server";
+import { AgentSpendChargeError } from "./error.js";
+import { toCardId, joinUrl, bestEffortIdempotencyKey, toStringMetadata, resolvePlatformApiBaseUrl, resolveAmount, extractCardId, extractPaymentHeader } from "./helpers.js";
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+export function createAgentSpendClient(options) {
+    if (!options.serviceApiKey && !options.crypto) {
+        throw new AgentSpendChargeError("At least one of serviceApiKey or crypto config must be provided", 500);
+    }
+    const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+    if (!fetchImpl) {
+        throw new AgentSpendChargeError("No fetch implementation available", 500);
+    }
+    const platformApiBaseUrl = resolvePlatformApiBaseUrl(options.platformApiBaseUrl);
+    // -------------------------------------------------------------------
+    // Lazy service_id fetch + cache
+    // -------------------------------------------------------------------
+    let cachedServiceId = null;
+    async function getServiceId() {
+        if (cachedServiceId)
+            return cachedServiceId;
+        if (!options.serviceApiKey)
+            return null;
+        try {
+            const res = await fetchImpl(joinUrl(platformApiBaseUrl, "/v1/service/me"), {
+                headers: { authorization: `Bearer ${options.serviceApiKey}` }
+            });
+            if (res.ok) {
+                const data = (await res.json());
+                cachedServiceId = data.id ?? null;
+            }
+        }
+        catch { /* graceful fallback */ }
+        return cachedServiceId;
+    }
+    // -------------------------------------------------------------------
+    // x402 singleton setup
+    // -------------------------------------------------------------------
+    let facilitator = null;
+    let resourceServer = null;
+    const cryptoNetwork = (options.crypto?.network ?? "eip155:8453");
+    if (options.crypto || options.serviceApiKey) {
+        const facilitatorUrl = options.crypto?.facilitatorUrl ?? "https://facilitator.openx402.ai";
+        facilitator = new HTTPFacilitatorClient({ url: facilitatorUrl });
+        resourceServer = new x402ResourceServer(facilitator);
+        registerExactEvmScheme(resourceServer);
+    }
+    // -------------------------------------------------------------------
+    // charge() — card-only
+    // -------------------------------------------------------------------
+    async function charge(cardIdInput, opts) {
+        if (!options.serviceApiKey) {
+            throw new AgentSpendChargeError("charge() requires serviceApiKey", 500);
+        }
+        const cardId = toCardId(cardIdInput);
+        if (!cardId) {
+            throw new AgentSpendChargeError("card_id must start with card_", 400);
+        }
+        if (!Number.isInteger(opts.amount_cents) || opts.amount_cents <= 0) {
+            throw new AgentSpendChargeError("amount_cents must be a positive integer", 400);
+        }
+        const payload = {
+            card_id: cardId,
+            amount_cents: opts.amount_cents,
+            currency: opts.currency ?? "usd",
+            ...(opts.description ? { description: opts.description } : {}),
+            ...(opts.metadata ? { metadata: opts.metadata } : {}),
+            idempotency_key: opts.idempotency_key ?? bestEffortIdempotencyKey()
+        };
+        const response = await fetchImpl(joinUrl(platformApiBaseUrl, "/v1/charge"), {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${options.serviceApiKey}`,
+                "content-type": "application/json"
+            },
+            body: JSON.stringify(payload)
+        });
+        const responseBody = (await response.json().catch(() => ({})));
+        if (!response.ok) {
+            throw new AgentSpendChargeError(typeof responseBody.error === "string" ? responseBody.error : "AgentSpend charge failed", response.status, responseBody);
+        }
+        return responseBody;
+    }
+    // -------------------------------------------------------------------
+    // resolvePayToAddress
+    // -------------------------------------------------------------------
+    async function resolvePayToAddress() {
+        if (options.crypto?.receiverAddress) {
+            return options.crypto.receiverAddress;
+        }
+        if (options.serviceApiKey) {
+            const response = await fetchImpl(joinUrl(platformApiBaseUrl, "/v1/crypto/deposit-address"), {
+                method: "POST",
+                headers: {
+                    authorization: `Bearer ${options.serviceApiKey}`,
+                    "content-type": "application/json"
+                },
+                body: JSON.stringify({ amount_cents: 0, currency: "usd" })
+            });
+            if (!response.ok) {
+                throw new AgentSpendChargeError("Failed to resolve crypto deposit address", 502);
+            }
+            const data = (await response.json());
+            if (!data.deposit_address) {
+                throw new AgentSpendChargeError("No deposit address returned", 502);
+            }
+            return data.deposit_address;
+        }
+        throw new AgentSpendChargeError("No crypto payTo address available", 500);
+    }
+    // -------------------------------------------------------------------
+    // build402Result — x402 Payment-Required format
+    // -------------------------------------------------------------------
+    async function build402Result(requestUrl, amountCents, currency) {
+        const serviceId = await getServiceId();
+        try {
+            const payTo = await resolvePayToAddress();
+            const paymentRequirements = {
+                scheme: "exact",
+                network: cryptoNetwork,
+                amount: String(amountCents),
+                asset: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", // USDC on Base
+                payTo,
+                maxTimeoutSeconds: 300,
+                extra: { name: "USD Coin", version: "2" }
+            };
+            const paymentRequired = {
+                x402Version: 2,
+                error: "Payment required",
+                resource: {
+                    url: requestUrl,
+                    description: `Payment of ${amountCents} cents`,
+                    mimeType: "application/json"
+                },
+                accepts: [paymentRequirements]
+            };
+            const headerValue = Buffer.from(JSON.stringify(paymentRequired)).toString("base64");
+            return {
+                outcome: "payment_required",
+                statusCode: 402,
+                body: {
+                    error: "Payment required",
+                    amount_cents: amountCents,
+                    currency,
+                    ...(serviceId ? {
+                        agentspend: {
+                            service_id: serviceId,
+                            amount_cents: amountCents,
+                        }
+                    } : {})
+                },
+                headers: { "Payment-Required": headerValue }
+            };
+        }
+        catch (error) {
+            console.error("[agentspend] Failed to resolve crypto payTo address — returning card-only 402:", error instanceof Error ? error.message : error);
+            return {
+                outcome: "payment_required",
+                statusCode: 402,
+                body: {
+                    error: "Payment required",
+                    amount_cents: amountCents,
+                    currency,
+                    ...(serviceId ? {
+                        agentspend: {
+                            service_id: serviceId,
+                            amount_cents: amountCents,
+                        }
+                    } : {})
+                },
+                headers: {}
+            };
+        }
+    }
+    // -------------------------------------------------------------------
+    // handleCardPayment
+    // -------------------------------------------------------------------
+    async function handleCardPayment(request, cardId, amountCents, currency, body, opts) {
+        if (!options.serviceApiKey) {
+            return { outcome: "error", statusCode: 500, body: { error: "Card payments require serviceApiKey" } };
+        }
+        try {
+            const chargeResult = await charge(cardId, {
+                amount_cents: amountCents,
+                currency,
+                description: opts.description,
+                metadata: opts.metadata ? toStringMetadata(opts.metadata(body)) : undefined,
+                idempotency_key: request.headers["x-request-id"] ?? request.headers["idempotency-key"] ?? undefined
+            });
+            const paymentContext = {
+                method: "card",
+                amount_cents: amountCents,
+                currency,
+                card_id: cardId,
+                remaining_limit_cents: chargeResult.remaining_limit_cents
+            };
+            return { outcome: "charged", paymentContext };
+        }
+        catch (error) {
+            if (error instanceof AgentSpendChargeError) {
+                if (error.statusCode === 403) {
+                    return build402Result(request.url, amountCents, currency);
+                }
+                if (error.statusCode === 402) {
+                    return { outcome: "error", statusCode: 402, body: { error: "Payment required", details: error.details } };
+                }
+                return { outcome: "error", statusCode: error.statusCode, body: { error: error.message, details: error.details } };
+            }
+            return { outcome: "error", statusCode: 500, body: { error: "Unexpected paywall failure" } };
+        }
+    }
+    // -------------------------------------------------------------------
+    // handleCryptoPayment
+    // -------------------------------------------------------------------
+    async function handleCryptoPayment(paymentHeader, amountCents, currency) {
+        if (!resourceServer) {
+            return { outcome: "error", statusCode: 500, body: { error: "Crypto payments not configured" } };
+        }
+        try {
+            let paymentPayload;
+            try {
+                paymentPayload = JSON.parse(Buffer.from(paymentHeader, "base64").toString("utf-8"));
+            }
+            catch {
+                return { outcome: "error", statusCode: 400, body: { error: "Invalid payment payload encoding" } };
+            }
+            const acceptedPayTo = paymentPayload
+                .accepted?.payTo;
+            const payTo = acceptedPayTo ?? await resolvePayToAddress();
+            const paymentRequirements = {
+                scheme: "exact",
+                network: cryptoNetwork,
+                amount: String(amountCents),
+                asset: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", // USDC on Base
+                payTo,
+                maxTimeoutSeconds: 300,
+                extra: { name: "USD Coin", version: "2" }
+            };
+            const verifyResult = await resourceServer.verifyPayment(paymentPayload, paymentRequirements);
+            if (!verifyResult.isValid) {
+                return {
+                    outcome: "error",
+                    statusCode: 402,
+                    body: { error: "Payment verification failed", details: verifyResult.invalidReason }
+                };
+            }
+            const settleResult = await resourceServer.settlePayment(paymentPayload, paymentRequirements);
+            if (!settleResult.success) {
+                return {
+                    outcome: "error",
+                    statusCode: 402,
+                    body: { error: "Payment settlement failed", details: settleResult.errorReason }
+                };
+            }
+            const paymentContext = {
+                method: "crypto",
+                amount_cents: amountCents,
+                currency,
+                transaction_hash: settleResult.transaction,
+                payer_address: verifyResult.payer ?? undefined,
+                network: cryptoNetwork
+            };
+            return { outcome: "crypto_paid", paymentContext };
+        }
+        catch (error) {
+            if (error instanceof AgentSpendChargeError) {
+                return { outcome: "error", statusCode: error.statusCode, body: { error: error.message, details: error.details } };
+            }
+            return {
+                outcome: "error",
+                statusCode: 500,
+                body: { error: "Crypto payment processing failed", details: error.message }
+            };
+        }
+    }
+    // -------------------------------------------------------------------
+    // processPaywall() — unified entry point for adapters
+    // -------------------------------------------------------------------
+    async function processPaywall(opts, request) {
+        const { amount } = opts;
+        if (typeof amount === "number") {
+            if (!Number.isInteger(amount) || amount <= 0) {
+                throw new AgentSpendChargeError("amount must be a positive integer", 500);
+            }
+        }
+        const body = request.body;
+        const effectiveAmount = resolveAmount(amount, body);
+        if (!Number.isInteger(effectiveAmount) || effectiveAmount <= 0) {
+            return { outcome: "error", statusCode: 400, body: { error: "Could not determine payment amount from request" } };
+        }
+        const currency = opts.currency ?? "usd";
+        // Check for crypto payment header
+        const paymentHeader = extractPaymentHeader(request.headers);
+        if (paymentHeader) {
+            return handleCryptoPayment(paymentHeader, effectiveAmount, currency);
+        }
+        // Check for card payment
+        const cardId = extractCardId(request.headers, body);
+        if (cardId) {
+            return handleCardPayment(request, cardId, effectiveAmount, currency, body, opts);
+        }
+        // Neither → 402
+        return build402Result(request.url, effectiveAmount, currency);
+    }
+    return { charge, processPaywall };
+}

package/dist/core/error.d.ts

@@ -0,0 +1,5 @@
+export declare class AgentSpendChargeError extends Error {
+    statusCode: number;
+    details: unknown;
+    constructor(message: string, statusCode: number, details?: unknown);
+}

package/dist/core/error.js

@@ -0,0 +1,9 @@
+export class AgentSpendChargeError extends Error {
+    statusCode;
+    details;
+    constructor(message, statusCode, details) {
+        super(message);
+        this.statusCode = statusCode;
+        this.details = details;
+    }
+}

package/dist/core/helpers.d.ts

@@ -0,0 +1,8 @@
+export declare function toCardId(input: unknown): string | null;
+export declare function joinUrl(base: string, path: string): string;
+export declare function bestEffortIdempotencyKey(): string;
+export declare function toStringMetadata(input: unknown): Record<string, string>;
+export declare function resolvePlatformApiBaseUrl(explicitBaseUrl: string | undefined): string;
+export declare function resolveAmount(amount: number | string | ((body: unknown) => number), body: unknown): number;
+export declare function extractCardId(headers: Record<string, string | undefined>, body: unknown): string | null;
+export declare function extractPaymentHeader(headers: Record<string, string | undefined>): string | undefined;

package/dist/core/helpers.js

@@ -0,0 +1,77 @@
+export function toCardId(input) {
+    if (typeof input !== "string") {
+        return null;
+    }
+    const trimmed = input.trim();
+    if (!trimmed.startsWith("card_")) {
+        return null;
+    }
+    return trimmed;
+}
+export function joinUrl(base, path) {
+    const normalizedBase = base.endsWith("/") ? base.slice(0, -1) : base;
+    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+    return `${normalizedBase}${normalizedPath}`;
+}
+export function bestEffortIdempotencyKey() {
+    const uuid = globalThis.crypto?.randomUUID?.();
+    if (uuid) {
+        return uuid;
+    }
+    return `auto_${Date.now()}_${Math.random().toString(16).slice(2)}`;
+}
+export function toStringMetadata(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+        return {};
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(input)) {
+        if (typeof value === "string") {
+            result[key] = value;
+        }
+        else if (typeof value === "number" && Number.isFinite(value)) {
+            result[key] = String(value);
+        }
+        else if (typeof value === "boolean") {
+            result[key] = value ? "true" : "false";
+        }
+    }
+    return result;
+}
+const DEFAULT_PLATFORM_API_BASE_URL = "https://api.agentspend.co";
+export function resolvePlatformApiBaseUrl(explicitBaseUrl) {
+    if (explicitBaseUrl && explicitBaseUrl.trim().length > 0) {
+        return explicitBaseUrl.trim();
+    }
+    const envValue = typeof process !== "undefined" && process.env ? process.env.AGENTSPEND_API_URL : undefined;
+    if (typeof envValue === "string" && envValue.trim().length > 0) {
+        return envValue.trim();
+    }
+    return DEFAULT_PLATFORM_API_BASE_URL;
+}
+export function resolveAmount(amount, body) {
+    if (typeof amount === "number") {
+        return amount;
+    }
+    else if (typeof amount === "string") {
+        const raw = body?.[amount];
+        return typeof raw === "number" ? raw : 0;
+    }
+    else {
+        return amount(body);
+    }
+}
+export function extractCardId(headers, body) {
+    const cardIdFromHeader = headers["x-card-id"];
+    let cardId = cardIdFromHeader ? toCardId(cardIdFromHeader) : null;
+    if (!cardId) {
+        const bodyCardId = typeof body?.card_id === "string"
+            ? body.card_id
+            : null;
+        cardId = toCardId(bodyCardId);
+    }
+    return cardId;
+}
+export function extractPaymentHeader(headers) {
+    return headers["payment-signature"] ?? headers["x-payment"] ?? undefined;
+}

package/dist/core/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./types.js";
+export * from "./error.js";
+export * from "./helpers.js";
+export { createAgentSpendClient } from "./client.js";
+export type { AgentSpendClient } from "./client.js";

package/dist/core/index.js

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export * from "./error.js";
+export * from "./helpers.js";
+export { createAgentSpendClient } from "./client.js";

package/dist/{index.d.ts → core/types.d.ts}

@@ -58,23 +58,6 @@ export interface ChargeOptions {
     metadata?: Record<string, string>;
     idempotency_key?: string;
 }
-export declare class AgentSpendChargeError extends Error {
-    statusCode: number;
-    details: unknown;
-    constructor(message: string, statusCode: number, details?: unknown);
-}
-export interface HonoContextLike {
-    req: {
-        header(name: string): string | undefined;
-        json(): Promise<unknown>;
-        url: string;
-        method: string;
-    };
-    json(body: unknown, status?: number): Response;
-    header(name: string, value: string): void;
-    set(key: string, value: unknown): void;
-    get(key: string): unknown;
-}
 export interface PaywallOptions {
     /**
      * Amount in cents.
@@ -87,9 +70,25 @@ export interface PaywallOptions {
     description?: string;
     metadata?: (body: unknown) => Record<string, unknown>;
 }
-export declare function getPaymentContext(c: HonoContextLike): PaywallPaymentContext | null;
-export interface AgentSpend {
-    charge(cardId: string, opts: ChargeOptions): Promise<ChargeResponse>;
-    paywall(opts: PaywallOptions): (c: HonoContextLike, next: () => Promise<void>) => Promise<Response | void>;
+export interface PaywallRequest {
+    url: string;
+    method: string;
+    headers: Record<string, string | undefined>;
+    body: unknown;
 }
-export declare function createAgentSpend(options: AgentSpendOptions): AgentSpend;
+export type PaywallResult = {
+    outcome: "charged";
+    paymentContext: PaywallPaymentContext;
+} | {
+    outcome: "crypto_paid";
+    paymentContext: PaywallPaymentContext;
+} | {
+    outcome: "payment_required";
+    statusCode: 402;
+    body: Record<string, unknown>;
+    headers: Record<string, string>;
+} | {
+    outcome: "error";
+    statusCode: number;
+    body: Record<string, unknown>;
+};

package/dist/core/types.js

@@ -0,0 +1,4 @@
+// ---------------------------------------------------------------------------
+// Types (inlined from @agentspend/types to avoid cross-repo publish)
+// ---------------------------------------------------------------------------
+export {};

package/dist/express/index.d.ts

@@ -0,0 +1,22 @@
+import type { AgentSpendOptions, ChargeOptions, ChargeResponse, PaywallOptions, PaywallPaymentContext } from "../core/types.js";
+export * from "../core/index.js";
+interface ExpressRequest {
+    body: unknown;
+    url: string;
+    method: string;
+    get(name: string): string | undefined;
+    header(name: string): string | undefined;
+    paymentContext?: PaywallPaymentContext;
+}
+interface ExpressResponse {
+    status(code: number): ExpressResponse;
+    set(name: string, value: string): ExpressResponse;
+    json(body: unknown): void;
+}
+type NextFunction = (err?: unknown) => void;
+export declare function getPaymentContext(req: ExpressRequest): PaywallPaymentContext | null;
+export interface AgentSpend {
+    charge(cardId: string, opts: ChargeOptions): Promise<ChargeResponse>;
+    paywall(opts: PaywallOptions): (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => void;
+}
+export declare function createAgentSpend(options: AgentSpendOptions): AgentSpend;

package/dist/express/index.js

@@ -0,0 +1,50 @@
+import { createAgentSpendClient } from "../core/client.js";
+export * from "../core/index.js";
+// ---------------------------------------------------------------------------
+// Payment context helper
+// ---------------------------------------------------------------------------
+export function getPaymentContext(req) {
+    return req.paymentContext ?? null;
+}
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+export function createAgentSpend(options) {
+    const client = createAgentSpendClient(options);
+    function paywall(opts) {
+        return function paywallMiddleware(req, res, next) {
+            const headerGet = (name) => req.get?.(name) ?? req.header?.(name);
+            const request = {
+                url: req.url,
+                method: req.method,
+                headers: {
+                    "x-card-id": headerGet("x-card-id"),
+                    "payment-signature": headerGet("payment-signature"),
+                    "x-payment": headerGet("x-payment"),
+                    "x-request-id": headerGet("x-request-id"),
+                    "idempotency-key": headerGet("idempotency-key"),
+                },
+                body: req.body
+            };
+            client.processPaywall(opts, request).then((result) => {
+                switch (result.outcome) {
+                    case "charged":
+                    case "crypto_paid":
+                        req.paymentContext = result.paymentContext;
+                        next();
+                        return;
+                    case "payment_required":
+                        for (const [key, value] of Object.entries(result.headers)) {
+                            res.set(key, value);
+                        }
+                        res.status(result.statusCode).json(result.body);
+                        return;
+                    case "error":
+                        res.status(result.statusCode).json(result.body);
+                        return;
+                }
+            }).catch((err) => next(err));
+        };
+    }
+    return { charge: client.charge, paywall };
+}

package/dist/fastify/index.d.ts

@@ -0,0 +1,27 @@
+import type { AgentSpendOptions, ChargeOptions, ChargeResponse, PaywallOptions, PaywallPaymentContext } from "../core/types.js";
+export * from "../core/index.js";
+interface FastifyRequest {
+    body: unknown;
+    url: string;
+    method: string;
+    headers: Record<string, string | string[] | undefined>;
+    paymentContext?: PaywallPaymentContext;
+}
+interface FastifyReply {
+    code(statusCode: number): FastifyReply;
+    header(name: string, value: string): FastifyReply;
+    send(body: unknown): FastifyReply;
+}
+interface FastifyInstance {
+    decorate(name: string, value: unknown): void;
+    decorateRequest(name: string, value: unknown): void;
+    addHook(name: string, handler: (req: FastifyRequest, reply: FastifyReply) => Promise<void>): void;
+}
+type DoneCallback = (err?: Error) => void;
+export declare function getPaymentContext(req: FastifyRequest): PaywallPaymentContext | null;
+export interface AgentSpend {
+    charge(cardId: string, opts: ChargeOptions): Promise<ChargeResponse>;
+    paywall(opts: PaywallOptions): (req: FastifyRequest, reply: FastifyReply) => Promise<void>;
+    plugin(opts: PaywallOptions): (fastify: FastifyInstance, _options: unknown, done: DoneCallback) => void;
+}
+export declare function createAgentSpend(options: AgentSpendOptions): AgentSpend;

package/dist/fastify/index.js

@@ -0,0 +1,58 @@
+import { createAgentSpendClient } from "../core/client.js";
+export * from "../core/index.js";
+// ---------------------------------------------------------------------------
+// Payment context helper
+// ---------------------------------------------------------------------------
+export function getPaymentContext(req) {
+    return req.paymentContext ?? null;
+}
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+export function createAgentSpend(options) {
+    const client = createAgentSpendClient(options);
+    function paywall(opts) {
+        return async function preHandler(req, reply) {
+            const headerGet = (name) => {
+                const val = req.headers[name];
+                return Array.isArray(val) ? val[0] : val;
+            };
+            const request = {
+                url: req.url,
+                method: req.method,
+                headers: {
+                    "x-card-id": headerGet("x-card-id"),
+                    "payment-signature": headerGet("payment-signature"),
+                    "x-payment": headerGet("x-payment"),
+                    "x-request-id": headerGet("x-request-id"),
+                    "idempotency-key": headerGet("idempotency-key"),
+                },
+                body: req.body
+            };
+            const result = await client.processPaywall(opts, request);
+            switch (result.outcome) {
+                case "charged":
+                case "crypto_paid":
+                    req.paymentContext = result.paymentContext;
+                    return;
+                case "payment_required":
+                    for (const [key, value] of Object.entries(result.headers)) {
+                        reply.header(key, value);
+                    }
+                    reply.code(result.statusCode).send(result.body);
+                    return;
+                case "error":
+                    reply.code(result.statusCode).send(result.body);
+                    return;
+            }
+        };
+    }
+    function plugin(opts) {
+        return function agentSpendPlugin(fastify, _options, done) {
+            fastify.decorateRequest("paymentContext", null);
+            fastify.addHook("preHandler", paywall(opts));
+            done();
+        };
+    }
+    return { charge: client.charge, paywall, plugin };
+}