@parallel-protocol/x402 0.5.3 → 0.7.0

package/dist/next.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
-var chunkXUNNMCO5_cjs = require('./chunk-XUNNMCO5.cjs');
-var chunkKQPIZ6SZ_cjs = require('./chunk-KQPIZ6SZ.cjs');
+var chunkPOU7EH3E_cjs = require('./chunk-POU7EH3E.cjs');
+require('./chunk-JPMK5YBU.cjs');
 var server = require('next/server');
 
 // src/next/adapter.ts
@@ -22,11 +22,22 @@ var NextAdapter = class {
   getUrl() {
     return this.req.url;
   }
+  // Read from a clone: a request body is a stream that can be consumed once,
+  // and the handler still needs the original.
+  async getBody() {
+    if (!chunkPOU7EH3E_cjs.isJsonContentType(this.req.headers.get("content-type") ?? void 0))
+      return void 0;
+    try {
+      return await this.req.clone().json();
+    } catch {
+      return void 0;
+    }
+  }
 };
 
 // src/next/index.ts
 function withPayment(config, handler) {
-  const gate = chunkKQPIZ6SZ_cjs.createPaymentGate(config);
+  const gate = chunkPOU7EH3E_cjs.createPaymentGate(config);
   return async (req) => {
     const gateResult = await gate(new NextAdapter(req));
     if (gateResult.type === "pass") {
@@ -43,20 +54,57 @@ function withPayment(config, handler) {
     }
     let response;
     try {
-      const outcome = await chunkXUNNMCO5_cjs.raceTimeout(handler(req));
-      if (outcome === chunkXUNNMCO5_cjs.HANDLER_TIMEOUT) {
+      const outcome = await chunkPOU7EH3E_cjs.raceTimeout(
+        handler(req),
+        gateResult.handlerTimeoutMs
+      );
+      if (outcome === chunkPOU7EH3E_cjs.HANDLER_TIMEOUT) {
         return new server.NextResponse(null, { status: 504 });
       }
       response = outcome;
     } catch {
       return new server.NextResponse(null, { status: 504 });
     }
+    let raw;
+    if (gateResult.scheme === "upto") {
+      raw = response.headers.get(chunkPOU7EH3E_cjs.SETTLE_AMOUNT_HEADER) ?? void 0;
+      if (raw !== void 0) {
+        const headers = new Headers(response.headers);
+        headers.delete(chunkPOU7EH3E_cjs.SETTLE_AMOUNT_HEADER);
+        response = new server.NextResponse(response.body, {
+          status: response.status,
+          headers
+        });
+      }
+    }
     if (response.status >= 200 && response.status < 300) {
+      let settleOptions;
+      if (gateResult.scheme === "upto") {
+        const handled = response;
+        const resolved = await chunkPOU7EH3E_cjs.resolveCharge(gateResult, raw, {
+          status: handled.status,
+          header: (name) => handled.headers.get(name) ?? void 0,
+          // Read from a clone: the body streams once, to the client.
+          body: () => chunkPOU7EH3E_cjs.jsonFromResponse(handled)
+        });
+        if (resolved.kind === "invalid") {
+          handled.body?.cancel().catch(() => {
+          });
+          return server.NextResponse.json(
+            chunkPOU7EH3E_cjs.invalidSettleAmountResponse(resolved.reason),
+            {
+              status: 402
+            }
+          );
+        }
+        if (resolved.kind === "skip") return response;
+        settleOptions = { amount: resolved.amount };
+      }
       try {
-        const settleResponse = await gateResult.settle();
+        const settleResponse = settleOptions ? await gateResult.settle(settleOptions) : await gateResult.settle();
         if (settleResponse.success) {
           const headers = new Headers(response.headers);
-          headers.set("payment-response", chunkKQPIZ6SZ_cjs.encodeBase64(settleResponse));
+          headers.set("payment-response", chunkPOU7EH3E_cjs.encodeBase64(settleResponse));
           headers.set("access-control-expose-headers", "payment-response");
           return new server.NextResponse(response.body, {
             status: response.status,
@@ -65,6 +113,8 @@ function withPayment(config, handler) {
         }
       } catch {
       }
+      response.body?.cancel().catch(() => {
+      });
       return server.NextResponse.json(
         {
           error: "PAYMENT_SETTLEMENT_FAILED",

package/dist/next.d.cts

@@ -1,5 +1,5 @@
 import { NextRequest, NextResponse } from 'next/server';
-import { H as HTTPAdapter, P as PaymentMiddlewareConfig } from './types-CUi55YSx.cjs';
+import { H as HTTPAdapter, P as PaymentMiddlewareConfig } from './types-q_gu5wjz.cjs';
 import 'viem';
 
 declare class NextAdapter implements HTTPAdapter {
@@ -9,6 +9,7 @@ declare class NextAdapter implements HTTPAdapter {
     getMethod(): string;
     getPath(): string;
     getUrl(): string;
+    getBody(): Promise<unknown>;
 }
 
 type NextHandler = (req: NextRequest) => Promise<NextResponse>;

package/dist/next.d.ts

@@ -1,5 +1,5 @@
 import { NextRequest, NextResponse } from 'next/server';
-import { H as HTTPAdapter, P as PaymentMiddlewareConfig } from './types-CUi55YSx.js';
+import { H as HTTPAdapter, P as PaymentMiddlewareConfig } from './types-q_gu5wjz.js';
 import 'viem';
 
 declare class NextAdapter implements HTTPAdapter {
@@ -9,6 +9,7 @@ declare class NextAdapter implements HTTPAdapter {
     getMethod(): string;
     getPath(): string;
     getUrl(): string;
+    getBody(): Promise<unknown>;
 }
 
 type NextHandler = (req: NextRequest) => Promise<NextResponse>;

package/dist/next.js

@@ -1,5 +1,5 @@
-import { raceTimeout, HANDLER_TIMEOUT } from './chunk-2UEAVMCH.js';
-import { createPaymentGate, encodeBase64 } from './chunk-75GLDK7L.js';
+import { isJsonContentType, createPaymentGate, raceTimeout, HANDLER_TIMEOUT, SETTLE_AMOUNT_HEADER, resolveCharge, jsonFromResponse, invalidSettleAmountResponse, encodeBase64 } from './chunk-AENXD4OC.js';
+import './chunk-AFRDHGDT.js';
 import { NextResponse } from 'next/server';
 
 // src/next/adapter.ts
@@ -20,6 +20,17 @@ var NextAdapter = class {
   getUrl() {
     return this.req.url;
   }
+  // Read from a clone: a request body is a stream that can be consumed once,
+  // and the handler still needs the original.
+  async getBody() {
+    if (!isJsonContentType(this.req.headers.get("content-type") ?? void 0))
+      return void 0;
+    try {
+      return await this.req.clone().json();
+    } catch {
+      return void 0;
+    }
+  }
 };
 
 // src/next/index.ts
@@ -41,7 +52,10 @@ function withPayment(config, handler) {
     }
     let response;
     try {
-      const outcome = await raceTimeout(handler(req));
+      const outcome = await raceTimeout(
+        handler(req),
+        gateResult.handlerTimeoutMs
+      );
       if (outcome === HANDLER_TIMEOUT) {
         return new NextResponse(null, { status: 504 });
       }
@@ -49,9 +63,43 @@ function withPayment(config, handler) {
     } catch {
       return new NextResponse(null, { status: 504 });
     }
+    let raw;
+    if (gateResult.scheme === "upto") {
+      raw = response.headers.get(SETTLE_AMOUNT_HEADER) ?? void 0;
+      if (raw !== void 0) {
+        const headers = new Headers(response.headers);
+        headers.delete(SETTLE_AMOUNT_HEADER);
+        response = new NextResponse(response.body, {
+          status: response.status,
+          headers
+        });
+      }
+    }
     if (response.status >= 200 && response.status < 300) {
+      let settleOptions;
+      if (gateResult.scheme === "upto") {
+        const handled = response;
+        const resolved = await resolveCharge(gateResult, raw, {
+          status: handled.status,
+          header: (name) => handled.headers.get(name) ?? void 0,
+          // Read from a clone: the body streams once, to the client.
+          body: () => jsonFromResponse(handled)
+        });
+        if (resolved.kind === "invalid") {
+          handled.body?.cancel().catch(() => {
+          });
+          return NextResponse.json(
+            invalidSettleAmountResponse(resolved.reason),
+            {
+              status: 402
+            }
+          );
+        }
+        if (resolved.kind === "skip") return response;
+        settleOptions = { amount: resolved.amount };
+      }
       try {
-        const settleResponse = await gateResult.settle();
+        const settleResponse = settleOptions ? await gateResult.settle(settleOptions) : await gateResult.settle();
         if (settleResponse.success) {
           const headers = new Headers(response.headers);
           headers.set("payment-response", encodeBase64(settleResponse));
@@ -63,6 +111,8 @@ function withPayment(config, handler) {
         }
       } catch {
       }
+      response.body?.cancel().catch(() => {
+      });
       return NextResponse.json(
         {
           error: "PAYMENT_SETTLEMENT_FAILED",

package/dist/types-q_gu5wjz.d.cts

@@ -0,0 +1,185 @@
+import { Address } from 'viem';
+
+interface FacilitatorConfig {
+    url: string;
+    apiKey?: string;
+}
+/**
+ * What a per-request price function sees. `body` is the request body as the
+ * framework parsed it (JSON), or `undefined` when there is none.
+ */
+interface PriceContext {
+    method: string;
+    path: string;
+    url: string;
+    header(name: string): string | undefined;
+    body: unknown;
+}
+/**
+ * Prices one request from its content. Called on the unpaid request to build
+ * the 402 and again on the paid retry, so it must be pure: same request, same
+ * price. Returns a price in the same format as a fixed `price`.
+ */
+type PriceFunction = (ctx: PriceContext) => string | bigint | Promise<string | bigint>;
+/**
+ * What a meter function sees once the handler has answered: the response
+ * (`body` is its JSON as parsed by the middleware, `undefined` when it is not
+ * JSON) and the request as the price function saw it.
+ */
+interface MeterContext {
+    status: number;
+    header(name: string): string | undefined;
+    body: unknown;
+    request: PriceContext;
+}
+/**
+ * Names the amount a metered route charges, from the handler's response.
+ * Returns an amount in the same format as `price`, bounded by the cap;
+ * `"0"` serves the request for free; `undefined` leaves the decision to the
+ * `payment-settle-amount` header, then to the cap.
+ */
+type MeterFunction = (ctx: MeterContext) => string | bigint | undefined | null | Promise<string | bigint | undefined | null>;
+interface RouteConfig {
+    /**
+     * A fixed amount (`"0.01"` or a bigint in the smallest unit), or a function
+     * of the request for resources priced per request.
+     */
+    price: string | bigint | PriceFunction;
+    /**
+     * Metered routes only: reads the amount to charge from the handler's
+     * response instead of the `payment-settle-amount` header.
+     */
+    meter?: MeterFunction;
+    decimals?: number;
+    network: string;
+    payTo: Address;
+    acceptedTokens?: Address[];
+    description?: string;
+    /**
+     * `exact` (default) charges `price` as invoiced. `upto` invoices `price` as a
+     * cap: the handler decides the actual amount through the
+     * `payment-settle-amount` response header and the remainder is refunded.
+     */
+    scheme?: "exact" | "upto";
+    /**
+     * Settlement window the payer signs for, in seconds (default 300). Metered
+     * routes announce how long their handler may take; the facilitator caps it
+     * at 3600. The handler must finish comfortably before it expires.
+     */
+    maxTimeoutSeconds?: number;
+}
+interface PaymentMiddlewareConfig {
+    facilitator: FacilitatorConfig;
+    routes: Record<string, RouteConfig>;
+}
+interface RunHandlerOptions {
+    /** Handler timeout for this request; defaults to the adapter's 30 s. */
+    timeoutMs?: number;
+}
+interface RunHandlerResult {
+    status: number;
+    setResponseHeader(name: string, value: string): void;
+    /** Reads a header the handler set on its response (metered routes). */
+    getResponseHeader?(name: string): string | undefined;
+    /** Strips a header before the response leaves (metered routes). */
+    removeResponseHeader?(name: string): void;
+    /**
+     * The handler's response body as JSON, for routes with a `meter` function;
+     * `undefined` when the response is not JSON.
+     */
+    getResponseBody?(): Promise<unknown>;
+    sendResponse(): void;
+    discardResponse(): void;
+}
+interface HTTPAdapter {
+    getHeader(name: string): string | undefined;
+    getMethod(): string;
+    getPath(): string;
+    getUrl(): string;
+    /** The parsed request body, for routes priced per request. */
+    getBody?(): Promise<unknown>;
+    runHandler?(options?: RunHandlerOptions): Promise<RunHandlerResult>;
+}
+interface ResourceInfo {
+    url: string;
+    description?: string;
+    mimeType?: string;
+}
+interface PaymentRequirements {
+    scheme: string;
+    network: string;
+    asset: string;
+    amount: string;
+    payTo: string;
+    maxTimeoutSeconds: number;
+    extra: Record<string, unknown>;
+}
+interface PaymentRequired {
+    x402Version: number;
+    error?: string;
+    resource: ResourceInfo;
+    accepts: PaymentRequirements[];
+    extensions?: Record<string, unknown>;
+}
+interface FacilitatorPaymentRequirements {
+    maxAmountRequired: string;
+    asset: string;
+    payTo: string;
+    network: string;
+    scheme?: "exact" | "upto";
+    maxTimeoutSeconds?: number;
+}
+/** Settle-time options — only metered (`upto`) routes use them. */
+interface SettleOptions {
+    /** Amount actually charged, in the asset's smallest unit. */
+    amount?: string;
+}
+interface PaymentConfirmation {
+    success: true;
+    txHash: Address;
+    route: string;
+    chain: string;
+    gasSponsored: boolean;
+    networkId: string;
+    /** Amount actually charged (smallest unit) — metered routes only. */
+    amountSettled?: string;
+}
+interface PaymentFailure {
+    success: false;
+    error: {
+        code: string;
+        message: string;
+        hint?: string;
+    };
+}
+type FacilitatorResponse = PaymentConfirmation | PaymentFailure;
+interface MiddlewareResult {
+    status: number;
+    headers: Record<string, string>;
+    body: unknown;
+}
+interface PassResult {
+    pass: true;
+    handlerRan?: true;
+}
+type VerifiedPayment = {
+    type: "verified";
+    scheme: "exact" | "upto";
+    /** The verified amount (smallest unit): the price, or the cap for `upto`. */
+    maxAmount: bigint;
+    decimals: number;
+    /** How long the handler may run before the middleware gives up on it. */
+    handlerTimeoutMs: number;
+    settle(options?: SettleOptions): Promise<FacilitatorResponse>;
+    /** The route's meter function, and the request it will be shown. */
+    meter?: MeterFunction;
+    request?: PriceContext;
+};
+type PaymentGateResult = {
+    type: "pass";
+} | {
+    type: "error";
+    result: MiddlewareResult;
+} | VerifiedPayment;
+
+export type { FacilitatorConfig as F, HTTPAdapter as H, MiddlewareResult as M, PaymentMiddlewareConfig as P, RunHandlerOptions as R, SettleOptions as S, VerifiedPayment as V, RunHandlerResult as a, FacilitatorPaymentRequirements as b, FacilitatorResponse as c, PaymentGateResult as d, PassResult as e, MeterContext as f, MeterFunction as g, PaymentConfirmation as h, PaymentFailure as i, PaymentRequired as j, PaymentRequirements as k, PriceContext as l, PriceFunction as m, ResourceInfo as n, RouteConfig as o };

package/dist/types-q_gu5wjz.d.ts

@@ -0,0 +1,185 @@
+import { Address } from 'viem';
+
+interface FacilitatorConfig {
+    url: string;
+    apiKey?: string;
+}
+/**
+ * What a per-request price function sees. `body` is the request body as the
+ * framework parsed it (JSON), or `undefined` when there is none.
+ */
+interface PriceContext {
+    method: string;
+    path: string;
+    url: string;
+    header(name: string): string | undefined;
+    body: unknown;
+}
+/**
+ * Prices one request from its content. Called on the unpaid request to build
+ * the 402 and again on the paid retry, so it must be pure: same request, same
+ * price. Returns a price in the same format as a fixed `price`.
+ */
+type PriceFunction = (ctx: PriceContext) => string | bigint | Promise<string | bigint>;
+/**
+ * What a meter function sees once the handler has answered: the response
+ * (`body` is its JSON as parsed by the middleware, `undefined` when it is not
+ * JSON) and the request as the price function saw it.
+ */
+interface MeterContext {
+    status: number;
+    header(name: string): string | undefined;
+    body: unknown;
+    request: PriceContext;
+}
+/**
+ * Names the amount a metered route charges, from the handler's response.
+ * Returns an amount in the same format as `price`, bounded by the cap;
+ * `"0"` serves the request for free; `undefined` leaves the decision to the
+ * `payment-settle-amount` header, then to the cap.
+ */
+type MeterFunction = (ctx: MeterContext) => string | bigint | undefined | null | Promise<string | bigint | undefined | null>;
+interface RouteConfig {
+    /**
+     * A fixed amount (`"0.01"` or a bigint in the smallest unit), or a function
+     * of the request for resources priced per request.
+     */
+    price: string | bigint | PriceFunction;
+    /**
+     * Metered routes only: reads the amount to charge from the handler's
+     * response instead of the `payment-settle-amount` header.
+     */
+    meter?: MeterFunction;
+    decimals?: number;
+    network: string;
+    payTo: Address;
+    acceptedTokens?: Address[];
+    description?: string;
+    /**
+     * `exact` (default) charges `price` as invoiced. `upto` invoices `price` as a
+     * cap: the handler decides the actual amount through the
+     * `payment-settle-amount` response header and the remainder is refunded.
+     */
+    scheme?: "exact" | "upto";
+    /**
+     * Settlement window the payer signs for, in seconds (default 300). Metered
+     * routes announce how long their handler may take; the facilitator caps it
+     * at 3600. The handler must finish comfortably before it expires.
+     */
+    maxTimeoutSeconds?: number;
+}
+interface PaymentMiddlewareConfig {
+    facilitator: FacilitatorConfig;
+    routes: Record<string, RouteConfig>;
+}
+interface RunHandlerOptions {
+    /** Handler timeout for this request; defaults to the adapter's 30 s. */
+    timeoutMs?: number;
+}
+interface RunHandlerResult {
+    status: number;
+    setResponseHeader(name: string, value: string): void;
+    /** Reads a header the handler set on its response (metered routes). */
+    getResponseHeader?(name: string): string | undefined;
+    /** Strips a header before the response leaves (metered routes). */
+    removeResponseHeader?(name: string): void;
+    /**
+     * The handler's response body as JSON, for routes with a `meter` function;
+     * `undefined` when the response is not JSON.
+     */
+    getResponseBody?(): Promise<unknown>;
+    sendResponse(): void;
+    discardResponse(): void;
+}
+interface HTTPAdapter {
+    getHeader(name: string): string | undefined;
+    getMethod(): string;
+    getPath(): string;
+    getUrl(): string;
+    /** The parsed request body, for routes priced per request. */
+    getBody?(): Promise<unknown>;
+    runHandler?(options?: RunHandlerOptions): Promise<RunHandlerResult>;
+}
+interface ResourceInfo {
+    url: string;
+    description?: string;
+    mimeType?: string;
+}
+interface PaymentRequirements {
+    scheme: string;
+    network: string;
+    asset: string;
+    amount: string;
+    payTo: string;
+    maxTimeoutSeconds: number;
+    extra: Record<string, unknown>;
+}
+interface PaymentRequired {
+    x402Version: number;
+    error?: string;
+    resource: ResourceInfo;
+    accepts: PaymentRequirements[];
+    extensions?: Record<string, unknown>;
+}
+interface FacilitatorPaymentRequirements {
+    maxAmountRequired: string;
+    asset: string;
+    payTo: string;
+    network: string;
+    scheme?: "exact" | "upto";
+    maxTimeoutSeconds?: number;
+}
+/** Settle-time options — only metered (`upto`) routes use them. */
+interface SettleOptions {
+    /** Amount actually charged, in the asset's smallest unit. */
+    amount?: string;
+}
+interface PaymentConfirmation {
+    success: true;
+    txHash: Address;
+    route: string;
+    chain: string;
+    gasSponsored: boolean;
+    networkId: string;
+    /** Amount actually charged (smallest unit) — metered routes only. */
+    amountSettled?: string;
+}
+interface PaymentFailure {
+    success: false;
+    error: {
+        code: string;
+        message: string;
+        hint?: string;
+    };
+}
+type FacilitatorResponse = PaymentConfirmation | PaymentFailure;
+interface MiddlewareResult {
+    status: number;
+    headers: Record<string, string>;
+    body: unknown;
+}
+interface PassResult {
+    pass: true;
+    handlerRan?: true;
+}
+type VerifiedPayment = {
+    type: "verified";
+    scheme: "exact" | "upto";
+    /** The verified amount (smallest unit): the price, or the cap for `upto`. */
+    maxAmount: bigint;
+    decimals: number;
+    /** How long the handler may run before the middleware gives up on it. */
+    handlerTimeoutMs: number;
+    settle(options?: SettleOptions): Promise<FacilitatorResponse>;
+    /** The route's meter function, and the request it will be shown. */
+    meter?: MeterFunction;
+    request?: PriceContext;
+};
+type PaymentGateResult = {
+    type: "pass";
+} | {
+    type: "error";
+    result: MiddlewareResult;
+} | VerifiedPayment;
+
+export type { FacilitatorConfig as F, HTTPAdapter as H, MiddlewareResult as M, PaymentMiddlewareConfig as P, RunHandlerOptions as R, SettleOptions as S, VerifiedPayment as V, RunHandlerResult as a, FacilitatorPaymentRequirements as b, FacilitatorResponse as c, PaymentGateResult as d, PassResult as e, MeterContext as f, MeterFunction as g, PaymentConfirmation as h, PaymentFailure as i, PaymentRequired as j, PaymentRequirements as k, PriceContext as l, PriceFunction as m, ResourceInfo as n, RouteConfig as o };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@parallel-protocol/x402",
-	"version": "0.5.3",
+	"version": "0.7.0",
 	"description": "Parallel Protocol x402 payment middleware — Express, Next.js, Fastify, Hono",
 	"author": "Parallel Protocol <contact@parallel.best>",
 	"repository": {
@@ -69,6 +69,16 @@
 				"default": "./dist/hono.cjs"
 			}
 		},
+		"./llm": {
+			"import": {
+				"types": "./dist/llm.d.ts",
+				"default": "./dist/llm.js"
+			},
+			"require": {
+				"types": "./dist/llm.d.cts",
+				"default": "./dist/llm.cjs"
+			}
+		},
 		"./package.json": "./package.json"
 	},
 	"files": [
@@ -123,7 +133,7 @@
 		"vitest": "^4.0.14"
 	},
 	"dependencies": {
-		"@parallel-protocol/chains": "^0.3.0",
+		"@parallel-protocol/chains": "^0.4.0",
 		"fastify-plugin": "^6.0.0",
 		"zod": "^4.4.3"
 	},

package/dist/chunk-2UEAVMCH.js

@@ -1,17 +0,0 @@
-// src/timeout.ts
-var HANDLER_TIMEOUT_MS = 3e4;
-var HANDLER_TIMEOUT = /* @__PURE__ */ Symbol("x402:handler-timeout");
-async function raceTimeout(promise, ms = HANDLER_TIMEOUT_MS) {
-  let timer;
-  const timeout = new Promise((resolve) => {
-    timer = setTimeout(() => resolve(HANDLER_TIMEOUT), ms);
-    timer.unref?.();
-  });
-  try {
-    return await Promise.race([promise, timeout]);
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-export { HANDLER_TIMEOUT, raceTimeout };