@belticlabs/agent-risk-sdk 0.7.0 → 0.8.0

package/dist/ai/index.d.ts

@@ -1,6 +1,6 @@
 import { LanguageModelMiddleware, ToolSet } from 'ai';
-import { S as Session } from '../session-DAN29XoB.js';
-import '../index-DAVKGJs5.js';
+import { S as Session } from '../session-DTIzd1EQ.js';
+import '../index-CBUSXzgG.js';
 import 'zod';
 
 declare function middleware(session: Session): LanguageModelMiddleware;

package/dist/ai/index.js

@@ -3,12 +3,10 @@ import {
 } from "../chunk-JGVVQUXQ.js";
 import {
   toJson,
-  toJsonObject
-} from "../chunk-FQDHFTVR.js";
-import {
+  toJsonObject,
   uuidv7
-} from "../chunk-UXXSE643.js";
-import "../chunk-FNU4CRJJ.js";
+} from "../chunk-MWXXX35V.js";
+import "../chunk-PDE55ZZV.js";
 
 // src/ai/index.ts
 var PARAM_KEYS = [

package/dist/{chunk-HI656UWG.js → chunk-DI3LZR65.js}

@@ -1,15 +1,9 @@
-import {
-  summaryOf
-} from "./chunk-M4I3FGZG.js";
 import {
   toJsonObject
-} from "./chunk-FQDHFTVR.js";
-import {
-  payloadDigest
-} from "./chunk-UXXSE643.js";
+} from "./chunk-MWXXX35V.js";
 import {
   Money
-} from "./chunk-FNU4CRJJ.js";
+} from "./chunk-PDE55ZZV.js";
 
 // src/x402/binding.ts
 var SESSION_EXTENSION = "beltic.sessionId";
@@ -19,9 +13,19 @@ function sessionIdOf(extensions) {
   return typeof v === "string" && v.length > 0 ? v : null;
 }
 
+// src/core/payment-moment.ts
+function summaryOf(m) {
+  return {
+    protocol: m.protocol,
+    payee: m.payee,
+    amount: { value: m.amount.value, currency: m.amount.currency },
+    ...m.payer ? { payer: m.payer } : {}
+  };
+}
+
 // src/x402/moments.ts
 import { z } from "zod";
-function x402Summary(accepts, opts = {}) {
+function summary(accepts, opts = {}) {
   const payer = opts.payer?.toLowerCase();
   return {
     protocol: "x402",
@@ -34,7 +38,7 @@ function x402Summary(accepts, opts = {}) {
   };
 }
 function fromAccepts(a, artifact, raw, payer) {
-  return { ...x402Summary(a, { payer }), artifact, raw };
+  return { ...summary(a, { payer }), artifact, raw };
 }
 function payerOf(payload) {
   const p = payload.payload ?? {};
@@ -50,6 +54,7 @@ function payerOf(payload) {
   return typeof hit === "string" ? hit.toLowerCase() : void 0;
 }
 var x402Moments = {
+  summary,
   /** The 402 challenge as the buyer saw it, from the `PAYMENT-REQUIRED` header. */
   required(required) {
     return fromAccepts(required.accepts?.[0], "http-402", toJsonObject(required));
@@ -89,54 +94,10 @@ var PriceSchema = z.union([
   z.object({ amount: z.string() }).transform((p) => p.amount)
 ]).catch("0");
 
-// src/x402/adapter.ts
-function attachX402(beltic, server, http) {
-  const inFlight = /* @__PURE__ */ new Map();
-  http?.onProtectedRequest(async (ctx, route) => {
-    if (ctx.paymentHeader) return;
-    const bound = ctx.adapter.getHeader(SESSION_HEADER) ?? ctx.adapter.getHeader(SESSION_HEADER.toLowerCase());
-    if (!bound) return;
-    const stream = await beltic.streams.ensure(bound);
-    const accepts = Array.isArray(route.accepts) ? route.accepts[0] : route.accepts;
-    await stream.emit(
-      "payment.requested",
-      x402Moments.route(accepts, {
-        path: ctx.path,
-        method: ctx.method,
-        route: JSON.parse(JSON.stringify(route))
-      })
-    );
-  });
-  server.onBeforeVerify(async (ctx) => {
-    const payload = ctx.paymentPayload;
-    const requirements = ctx.requirements;
-    const stream = await beltic.streams.ensure(sessionIdOf(payload.extensions));
-    if (stream.born === "seller")
-      await stream.emit("payment.requested", x402Moments.requirements(requirements));
-    const presented = x402Moments.payload(payload);
-    await stream.emit("payment.presented", presented);
-    inFlight.set(payloadDigest(payload), stream);
-    const decision = await beltic.evaluate(stream.id, summaryOf(presented));
-    if (decision.absent || decision.allowed) return;
-    return {
-      abort: true,
-      reason: `BELTIC_${decision.value}`,
-      message: decision.reasonCodes.join(",")
-    };
-  });
-  server.onAfterSettle(async (ctx) => {
-    const key = payloadDigest(ctx.paymentPayload);
-    const stream = inFlight.get(key);
-    if (!stream) return;
-    inFlight.delete(key);
-    if (ctx.result.success) await stream.close("settled", { transaction: ctx.result.transaction });
-  });
-}
-
 export {
+  summaryOf,
   SESSION_EXTENSION,
   SESSION_HEADER,
-  x402Summary,
-  x402Moments,
-  attachX402
+  sessionIdOf,
+  x402Moments
 };

package/dist/{chunk-UXXSE643.js → chunk-MWXXX35V.js}

@@ -304,6 +304,31 @@ function didKeyFromEd25519(publicKey) {
 // ../canon/src/session-id.ts
 import { randomBytes as randomBytes2 } from "crypto";
 
+// src/core/json.ts
+function toJson(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value === "bigint") return value.toString();
+  if (value instanceof Uint8Array) return { $bytes: Buffer.from(value).toString("base64") };
+  if (value instanceof Date) return value.toISOString();
+  if (value instanceof URL) return value.toString();
+  if (Array.isArray(value)) return value.map(toJson);
+  if (typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (v === void 0 || typeof v === "function") continue;
+      out[k] = toJson(v);
+    }
+    return out;
+  }
+  return null;
+}
+function toJsonObject(value) {
+  const j = toJson(value);
+  return j && typeof j === "object" && !Array.isArray(j) ? j : { value: j };
+}
+
 export {
   toHex,
   fromHex,
@@ -313,5 +338,7 @@ export {
   memorySigner,
   Chain,
   didKeyFromEd25519,
-  uuidv7
+  uuidv7,
+  toJson,
+  toJsonObject
 };

package/dist/chunk-P3VZNH5W.js

@@ -0,0 +1,57 @@
+import {
+  SESSION_HEADER,
+  sessionIdOf,
+  summaryOf,
+  x402Moments
+} from "./chunk-DI3LZR65.js";
+import {
+  payloadDigest
+} from "./chunk-MWXXX35V.js";
+
+// src/x402/adapter.ts
+function attachX402(beltic, server, http) {
+  const inFlight = /* @__PURE__ */ new Map();
+  http?.onProtectedRequest(async (ctx, route) => {
+    if (ctx.paymentHeader) return;
+    const bound = ctx.adapter.getHeader(SESSION_HEADER) ?? ctx.adapter.getHeader(SESSION_HEADER.toLowerCase());
+    if (!bound) return;
+    const stream = await beltic.streams.ensure(bound);
+    const accepts = Array.isArray(route.accepts) ? route.accepts[0] : route.accepts;
+    await stream.emit(
+      "payment.requested",
+      x402Moments.route(accepts, {
+        path: ctx.path,
+        method: ctx.method,
+        route: JSON.parse(JSON.stringify(route))
+      })
+    );
+  });
+  server.onBeforeVerify(async (ctx) => {
+    const payload = ctx.paymentPayload;
+    const requirements = ctx.requirements;
+    const stream = await beltic.streams.ensure(sessionIdOf(payload.extensions));
+    if (stream.born === "seller")
+      await stream.emit("payment.requested", x402Moments.requirements(requirements));
+    const presented = x402Moments.payload(payload);
+    await stream.emit("payment.presented", presented);
+    inFlight.set(payloadDigest(payload), stream);
+    const decision = await beltic.evaluate(stream.id, summaryOf(presented));
+    if (decision.absent || decision.allowed) return;
+    return {
+      abort: true,
+      reason: `BELTIC_${decision.value}`,
+      message: decision.reasonCodes.join(",")
+    };
+  });
+  server.onAfterSettle(async (ctx) => {
+    const key = payloadDigest(ctx.paymentPayload);
+    const stream = inFlight.get(key);
+    if (!stream) return;
+    inFlight.delete(key);
+    if (ctx.result.success) await stream.close("settled", { transaction: ctx.result.transaction });
+  });
+}
+
+export {
+  attachX402
+};

package/dist/{chunk-FNU4CRJJ.js → chunk-PDE55ZZV.js}

@@ -350,6 +350,13 @@ var EvaluateInputSchema = z5.strictObject({
   callId: z5.string().min(1).max(256).optional()
 }).describe("evaluate input");
 var CreatePolicyInputSchema = z5.strictObject({ rules: PolicyRulesSchema }).describe("policy input");
+var MAX_CATALOG_RESULTS = 20;
+var CatalogQuerySchema = z5.strictObject({
+  q: z5.string().trim().min(1).max(200),
+  /** Only endpoints that accept payment on this CAIP-2 network, e.g. `eip155:8453`. */
+  network: z5.string().min(1).max(128).optional(),
+  limit: z5.coerce.number().int().min(1).max(MAX_CATALOG_RESULTS).default(8)
+}).describe("catalog query");
 var ApiErrorSchema = z5.strictObject({
   error: z5.strictObject({
     code: z5.string().min(1),
@@ -541,6 +548,8 @@ export {
   PaymentSummarySchema,
   EvaluateInputSchema,
   CreatePolicyInputSchema,
+  MAX_CATALOG_RESULTS,
+  CatalogQuerySchema,
   ApiErrorSchema,
   payloadSchemaFor,
   Verdict

package/dist/client-DFZL4Pt3.d.ts

@@ -0,0 +1,298 @@
+import { J as JsonValue, e as CatalogQuery, d as CatalogOutput, N as JsonObject, W as PaymentSummary, o as DeclaredIntent } from './index-CBUSXzgG.js';
+import { A as ApiClient, S as Session, b as SessionOptions, a as Decision } from './session-DTIzd1EQ.js';
+import { z } from 'zod';
+
+/**
+ * One way to pay, as the seller wrote it: the fields a wallet needs are
+ * checked, everything else (`extra`, the scheme's own parts) is kept so the
+ * chosen entry can be echoed back as `accepted`.
+ */
+declare const Requirement: z.ZodObject<{
+    scheme: z.ZodString;
+    network: z.ZodString;
+    asset: z.ZodString;
+    amount: z.ZodString;
+    payTo: z.ZodString;
+    maxTimeoutSeconds: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+type X402Requirement = z.infer<typeof Requirement>;
+/** The whole challenge a quote answers: payment options, the resource, and the request the seller expects (`bazaar` extension). */
+declare const Challenge: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<unknown, string>>, z.ZodObject<{
+    x402Version: z.ZodLiteral<2>;
+    accepts: z.ZodArray<z.ZodUnknown>;
+    resource: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+        url: z.ZodString;
+        description: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    }, z.core.$loose>>>;
+    extensions: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+        bazaar: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+            info: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+                input: z.ZodCatch<z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+            }, z.core.$loose>>>;
+            schema: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+                properties: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+                    input: z.ZodCatch<z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+                }, z.core.$loose>>>;
+            }, z.core.$loose>>>;
+        }, z.core.$loose>>>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>>, z.ZodTransform<{
+    resource: {
+        url: string;
+        description: string | undefined;
+    } | null;
+    accepts: {
+        [x: string]: unknown;
+        scheme: string;
+        network: string;
+        asset: string;
+        amount: string;
+        payTo: string;
+        maxTimeoutSeconds?: number | undefined;
+    }[];
+    input: string | number | boolean | JsonValue[] | {
+        [key: string]: JsonValue;
+    } | null;
+    inputSchema: string | number | boolean | JsonValue[] | {
+        [key: string]: JsonValue;
+    } | null;
+}, {
+    [x: string]: unknown;
+    x402Version: 2;
+    accepts: unknown[];
+    resource?: {
+        [x: string]: unknown;
+        url: string;
+        description?: string | undefined;
+    } | undefined;
+    extensions?: {
+        [x: string]: unknown;
+        bazaar?: {
+            [x: string]: unknown;
+            info?: {
+                [x: string]: unknown;
+                input?: JsonValue | undefined;
+            } | undefined;
+            schema?: {
+                [x: string]: unknown;
+                properties?: {
+                    [x: string]: unknown;
+                    input?: JsonValue | undefined;
+                } | undefined;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+}>>;
+type X402Challenge = z.output<typeof Challenge>;
+/** The seller's settlement of a paid request (`PAYMENT-RESPONSE`). */
+declare const Settlement: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<unknown, string>>, z.ZodObject<{
+    success: z.ZodBoolean;
+    transaction: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    network: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    payer: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    errorReason: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    errorMessage: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+}, z.core.$loose>>;
+type X402Settlement = z.output<typeof Settlement>;
+
+/**
+ * x402 artifacts → protocol moments (Fraud SDK RFC › Protocol Adapter —
+ * x402). The moment is normalized (payee, amount, payer) so both sides of
+ * a purchase compare; the artifact travels whole in `raw`. For x402 the
+ * currency is `<network>/<asset>` (GAP-49) and the value is the atomic
+ * amount as the protocol carries it — `beltic.x402.summary` gives a buyer
+ * the same normalization for the payment it is about to evaluate, so what
+ * it asks about and what the fetch records are one and the same.
+ */
+
+/**
+ * The minimum an `accepts` entry needs to become a moment; unknown parts
+ * are named, never dropped.
+ */
+interface AcceptsLike {
+    payTo?: string | undefined;
+    amount?: string | undefined;
+    network?: string | undefined;
+    asset?: string | undefined;
+}
+
+/**
+ * x402 on the buyer half, as `beltic.x402` (Fraud SDK RFC › Protocol
+ * Adapter — x402):
+ *
+ *   catalog  where to buy: the platform's live search of public x402
+ *            catalogs (GAP-90)
+ *   fetch    the paying fetch, observed. It sits *inside* the agent's
+ *            paying fetch, so it sees the 402 → `payment.requested` and the
+ *            retry carrying the payment → `payment.presented`, into which
+ *            it injects the session binding (GAP-30). Before a request that
+ *            presents payment leaves, the session's evidence is flushed: the
+ *            seller evaluates as soon as it sees the payment (GAP-66). It
+ *            never pays and never decides.
+ *   quote    the price of a request before paying it: the same request
+ *            through `fetch` (so the 402 is on record), its challenge read —
+ *            payment options, resource, the request the seller expects
+ *   pay      the same request again, carrying the payment the wallet
+ *            signed for the chosen option, and the settlement it answered.
+ *            Signing is the wallet's: the SDK never holds a key
+ *   summary  an `accepts` entry as the payment `session.decide` takes
+ *   intent   a mandate for x402 spend, its cap in the rail's currency
+ *
+ * Only x402 v2 is read (GAP-72), and nothing here loads `@x402/*`: a buyer
+ * is observed without installing it. The seller half is `attachX402` in
+ * `/x402` and the middleware in `/hono`.
+ */
+
+/** What `catalog` searches for: `q` is required, `limit` defaults to 8 on the platform (1..20). */
+type CatalogSearch = Omit<CatalogQuery, 'limit'> & {
+    limit?: number | undefined;
+};
+/** The request a paid resource is called with; `quote` and the payment send the same one. */
+interface X402Request {
+    /** `GET` without a body, `POST` with one, unless given. */
+    method?: string | undefined;
+    /** Sent as JSON. */
+    body?: JsonValue | undefined;
+}
+interface X402Quote {
+    /** The status the resource answered the unpaid request with. */
+    status: number;
+    /** Its v2 challenge when it answered 402 with one; null when it asked for nothing or in a form this does not read. */
+    challenge: X402Challenge | null;
+}
+/** A payment the wallet signed: the option it accepted, as the challenge listed it, and the scheme's payload. */
+interface X402Signed {
+    accepted: X402Requirement;
+    /** Scheme-specific, e.g. `exact` on EVM: `{ authorization, signature }` (EIP-3009). */
+    payload: JsonObject;
+}
+interface X402Payment {
+    /** The resource's answer to the paid request; its body is unread. */
+    response: Response;
+    /** The seller's `PAYMENT-RESPONSE`, when it sent one. */
+    settlement: X402Settlement | null;
+}
+interface X402IntentInput {
+    mandate: string;
+    network: string;
+    asset: string;
+    /** Atomic units of `asset`, as x402 carries amounts — a decimal string or a bigint, never a float. */
+    maxAmount: string | bigint;
+    validUntil: string | Date;
+    merchantAllowlist?: string[] | undefined;
+}
+declare class X402 {
+    private readonly api;
+    constructor(api: ApiClient);
+    /**
+     * x402-payable APIs matching `q`, grouped by vendor, as the platform finds
+     * them live in public catalogs (GAP-90); with `network`, only what can be
+     * paid there. `sources` says which catalogs answered. Null when the
+     * platform could not be reached (GAP-70); a rejected query throws.
+     */
+    catalog(search: CatalogSearch): Promise<CatalogOutput | null>;
+    /**
+     * A fetch bound to `session` that records what x402 crosses it. A request
+     * made while the session has no stream (the platform could not open one,
+     * GAP-70) goes through unrecorded.
+     */
+    fetch(session: Session): typeof globalThis.fetch;
+    /** The unpaid request, sent as it will be paid, and the challenge it answered. */
+    quote(session: Session, url: string, request?: X402Request): Promise<X402Quote>;
+    /**
+     * The request, sent as it was quoted, carrying `signed` as an x402 v2
+     * `PAYMENT-SIGNATURE` through `fetch` — so the presentation is recorded,
+     * bound to the session and flushed before it leaves (GAP-66). What the
+     * seller settled is read, not recorded (GAP-77).
+     */
+    pay(session: Session, url: string, signed: X402Signed, request?: X402Request): Promise<X402Payment>;
+    /** An `accepts` entry as the payment `session.decide` takes — the normalization the recorded moments use. */
+    summary(accepts: AcceptsLike | undefined, opts?: {
+        payer?: string | undefined;
+    }): PaymentSummary;
+    /**
+     * The declared intent for an x402 mandate (Fraud SDK RFC › Session ›
+     * `intent.declared`). The cap must be in the currency the rail's moments
+     * carry — `<network>/<asset>`, atomic units (GAP-49) — or the platform's
+     * spend detectors compare two currencies and never meet.
+     */
+    intent(input: X402IntentInput): DeclaredIntent;
+    /** The request as `quote` and `pay` send it: `GET` bare, `POST` with a JSON body, unless told otherwise. */
+    private static init;
+    /** An x402 header value: base64 of the JSON. */
+    private static encode;
+}
+
+/**
+ * One SDK, two halves (Fraud SDK RFC › Summary). `Beltic` is the single
+ * client: `session` for the buyer half, `evaluate` for whichever half is
+ * about to let a payment through, and `x402` for what the buyer does on
+ * that rail — find an API (`catalog`, GAP-90), observe the paying fetch
+ * (`fetch`), read a price and pay it (`quote`, `pay`), shape what it asks
+ * about (`summary`, `intent`). Integrations that pull an optional peer are plain functions
+ * behind subpath exports:
+ *
+ *   @belticlabs/agent-risk-sdk/ai    → middleware(session), wrapTools(session, …)
+ *   @belticlabs/agent-risk-sdk/x402  → attachX402(beltic, …)              (seller)
+ *   @belticlabs/agent-risk-sdk/hono  → belticPaymentMiddleware(beltic, …) (seller)
+ *
+ * Neither half decides risk locally: verdicts are platform-side.
+ *
+ * A client is configured or it is not constructed — `Beltic.fromEnv()`
+ * reads `BELTIC_*`, and there is no disabled client (GAP-78). Evidence is
+ * a side channel of the work it observes, so a platform outage never
+ * throws into that work (GAP-70): the transport waits it out, `session`
+ * runs without a stream, `evaluate` answers `Decision.absent()` — never an
+ * invented verdict — and `x402.catalog` answers `null`. What the platform
+ * *rejects* (a 4xx, a forked chain) is the client's fault and throws.
+ */
+
+declare const SDK_VERSION = "0.8.0";
+interface BelticOptions {
+    apiKey: string;
+    baseUrl: string;
+    /** The agent's 32-byte Ed25519 seed as 64 hex — the buyer half. Without it, `session` is unavailable; the seller half works. */
+    agentSeed?: string | undefined;
+}
+declare class Beltic {
+    /** x402 for the buyer: `catalog`, `fetch`, `quote`, `pay`, `summary`, `intent`. */
+    readonly x402: X402;
+    private readonly api;
+    private readonly transport;
+    /** Open handles by conversation id (GAP-84). */
+    private readonly sessions;
+    /**
+     * The client the environment describes: `BELTIC_API_KEY` and
+     * `BELTIC_BASE_URL`, both required, and `BELTIC_AGENT_SEED` (64 hex) for
+     * the buyer half. A missing required variable is a configuration error,
+     * thrown (GAP-78).
+     */
+    static fromEnv(env?: Record<string, string | undefined>): Beltic;
+    constructor(opts: BelticOptions);
+    /**
+     * A conversation: new without an id, resumed with one — the id `session.id()`
+     * answered in this or any earlier process (GAP-84). One handle per
+     * conversation in-process until it closes; the options count when a
+     * session is opened. See `Session`.
+     */
+    session(id?: string, opts?: SessionOptions): Session;
+    /**
+     * The platform's verdict on a payment — the seller's before it verifies,
+     * the buyer's before it presents (Fraud SDK RFC › Evaluation Client).
+     * Read-your-writes: the session's buffered evidence is flushed first so
+     * the platform judges what the caller already saw (GAP-16/88). With a `callId`
+     * the platform answers the decision already taken for that call anywhere
+     * in the conversation (GAP-84). Absent when the platform could not be
+     * reached (GAP-70).
+     */
+    evaluate(sessionId: string, payment: PaymentSummary, opts?: {
+        callId?: string | undefined;
+    }): Promise<Decision>;
+    /** Send everything buffered now — every session's — and wait for that attempt. */
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+    /** `process.env` where there is a `process` (Node); `{}` on workerd, where the shell passes its `env`. */
+    private static processEnv;
+}
+
+export { type AcceptsLike as A, Beltic as B, type CatalogSearch as C, SDK_VERSION as S, X402 as X, type BelticOptions as a, type X402Challenge as b, type X402IntentInput as c, type X402Payment as d, type X402Quote as e, type X402Request as f, type X402Requirement as g, type X402Settlement as h, type X402Signed as i };

package/dist/{index-DAVKGJs5.d.ts → index-CBUSXzgG.d.ts}

@@ -189,6 +189,11 @@ interface ChainHead {
     digest: Hex64;
 }
 
+/**
+ * Request / response contracts of the Anti-Fraud API (Fraud Engine RFC › API).
+ * Additive fields beyond the RFC are marked with their GAP.
+ */
+
 declare const DeclaredIntentSchema: z.ZodObject<{
     mandate: z.ZodString;
     maxAmount: z.ZodOptional<z.ZodObject<{
@@ -316,6 +321,50 @@ interface CreatePolicyOutput {
     version: number;
     status: 'ACTIVE' | 'SUPERSEDED' | 'DRAFT';
 }
+/** The most a catalog search answers: the upstream search caps a page at 20 (GAP-90). */
+declare const MAX_CATALOG_RESULTS = 20;
+/** Non-RFC surface (GAP-90): x402-payable APIs matching a query, searched live in public catalogs. */
+declare const CatalogQuerySchema: z.ZodObject<{
+    q: z.ZodString;
+    network: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+type CatalogQuery = z.infer<typeof CatalogQuerySchema>;
+/** One way to pay an endpoint. `amount` is atomic and null when the price depends on the request. */
+interface CatalogOffer {
+    network: string;
+    asset: string;
+    amount: string | null;
+    /** Null when the catalog does not name the payee; the endpoint's 402 does. */
+    payTo: string | null;
+}
+interface CatalogEndpoint {
+    url: string;
+    method: string;
+    description: string;
+    source: string;
+    pricing: 'fixed' | 'dynamic';
+    accepts: CatalogOffer[];
+    /** The request shape the catalog publishes (method, body type, an example), when it does. */
+    input?: JsonValue;
+    /** The JSON Schema of that input, when the catalog publishes one. */
+    inputSchema?: JsonValue;
+}
+interface CatalogVendor {
+    vendor: string;
+    endpoints: CatalogEndpoint[];
+}
+/** How each catalog answered; one that failed does not fail the search. */
+interface CatalogSourceReport {
+    name: string;
+    ok: boolean;
+    count: number;
+    error?: string;
+}
+interface CatalogOutput {
+    vendors: CatalogVendor[];
+    sources: CatalogSourceReport[];
+}
 /** Error envelope (GAP-20). */
 declare const ApiErrorSchema: z.ZodObject<{
     error: z.ZodObject<{
@@ -519,4 +568,4 @@ interface PayloadByKind {
     'platform.anomaly': PlatformAnomalyPayload;
 }
 
-export { type Sig as $, ALL_SOURCES as A, type LlmCallParams as B, type ChainHead as C, type Decision as D, type EvidenceSourceAll as E, type LlmCallStartPayload as F, type GatewayDecisionPayload as G, type Hex64 as H, type IntentDeclaredPayload as I, type JsonValue as J, type PaymentMomentPayload as K, type LlmCallEndPayload as L, MAX_BATCH_EVENTS as M, type PaymentSummary as N, PaymentSummarySchema as O, type PayloadByKind as P, type PlatformAnomalyPayload as Q, type PlatformEvidenceKind as R, type PlatformObservationPayload as S, type PromptBase as T, type PromptDelta as U, SESSION_ID_CHARS as V, SESSION_ID_PREFIX as W, SOURCE_ORDER as X, type SessionClosePayload as Y, SessionIdSchema as Z, type SessionOpenPayload as _, type ApiError as a, TimestampSchema as a0, type ToolCallEndPayload as a1, type ToolCallStartPayload as a2, type TransportGapPayload as a3, type WireEvidenceKind as a4, chainKey as a5, compareByArrival as a6, compareBySessionSource as a7, compareBySourceSeq as a8, compareRootFirst as a9, payloadSchemaFor as aa, withinHeads as ab, ApiErrorSchema as b, CreatePolicyInputSchema as c, type CreatePolicyOutput as d, type CreateSessionInput as e, CreateSessionInputSchema as f, type CreateSessionOutput as g, type DeclaredIntent as h, DeclaredIntentSchema as i, type DigestedEnvelope as j, type EvaluateInput as k, EvaluateInputSchema as l, type EvaluateOutput as m, type EventResult as n, type EvidenceAck as o, EvidenceBatchInputSchema as p, type EvidenceEnvelope as q, type EvidenceEvent as r, EvidenceEventSchema as s, type EvidenceKind as t, type EvidenceSource as u, EvidenceSourceAllSchema as v, EvidenceSourceSchema as w, Hex64Schema as x, type JsonObject as y, JsonValueSchema as z };
+export { type PromptBase as $, ALL_SOURCES as A, type EvidenceKind as B, type CatalogEndpoint as C, type Decision as D, type EvidenceSourceAll as E, type EvidenceSource as F, EvidenceSourceAllSchema as G, EvidenceSourceSchema as H, type GatewayDecisionPayload as I, type JsonValue as J, type Hex64 as K, Hex64Schema as L, type IntentDeclaredPayload as M, type JsonObject as N, JsonValueSchema as O, type LlmCallEndPayload as P, type LlmCallParams as Q, type LlmCallStartPayload as R, MAX_BATCH_EVENTS as S, MAX_CATALOG_RESULTS as T, type PayloadByKind as U, type PaymentMomentPayload as V, type PaymentSummary as W, PaymentSummarySchema as X, type PlatformAnomalyPayload as Y, type PlatformEvidenceKind as Z, type PlatformObservationPayload as _, type ApiError as a, type PromptDelta as a0, SESSION_ID_CHARS as a1, SESSION_ID_PREFIX as a2, SOURCE_ORDER as a3, type SessionClosePayload as a4, SessionIdSchema as a5, type SessionOpenPayload as a6, type Sig as a7, TimestampSchema as a8, type ToolCallEndPayload as a9, type ToolCallStartPayload as aa, type TransportGapPayload as ab, type WireEvidenceKind as ac, chainKey as ad, compareByArrival as ae, compareBySessionSource as af, compareBySourceSeq as ag, compareRootFirst as ah, payloadSchemaFor as ai, withinHeads as aj, ApiErrorSchema as b, type CatalogOffer as c, type CatalogOutput as d, type CatalogQuery as e, CatalogQuerySchema as f, type CatalogSourceReport as g, type CatalogVendor as h, type ChainHead as i, CreatePolicyInputSchema as j, type CreatePolicyOutput as k, type CreateSessionInput as l, CreateSessionInputSchema as m, type CreateSessionOutput as n, type DeclaredIntent as o, DeclaredIntentSchema as p, type DigestedEnvelope as q, type EvaluateInput as r, EvaluateInputSchema as s, type EvaluateOutput as t, type EventResult as u, type EvidenceAck as v, EvidenceBatchInputSchema as w, type EvidenceEnvelope as x, type EvidenceEvent as y, EvidenceEventSchema as z };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-export { B as Beltic, a as BelticOptions, S as SDK_VERSION } from './client-Xn9M58OJ.js';
-export { B as BelticApiError, C as ChainRejectedError, D as DecideOptions, a as Decision, H as HumanDecisionInput, S as Session, b as SessionOptions } from './session-DAN29XoB.js';
-import './index-DAVKGJs5.js';
+export { A as AcceptsLike, B as Beltic, a as BelticOptions, C as CatalogSearch, S as SDK_VERSION, X as X402, b as X402Challenge, c as X402IntentInput, d as X402Payment, e as X402Quote, f as X402Request, g as X402Requirement, h as X402Settlement, i as X402Signed } from './client-DFZL4Pt3.js';
+export { B as BelticApiError, C as ChainRejectedError, D as DecideOptions, a as Decision, H as HumanDecisionInput, S as Session, b as SessionOptions } from './session-DTIzd1EQ.js';
+import './index-CBUSXzgG.js';
 import 'zod';
 
 /**

package/dist/index.js

@@ -2,8 +2,11 @@ import {
   openCall
 } from "./chunk-JGVVQUXQ.js";
 import {
-  summaryOf
-} from "./chunk-M4I3FGZG.js";
+  SESSION_EXTENSION,
+  SESSION_HEADER,
+  summaryOf,
+  x402Moments
+} from "./chunk-DI3LZR65.js";
 import {
   Chain,
   canonicalBytes,
@@ -12,11 +15,13 @@ import {
   memorySigner,
   sha256,
   toHex
-} from "./chunk-UXXSE643.js";
+} from "./chunk-MWXXX35V.js";
 import {
   ApiErrorSchema,
-  Hex64Schema
-} from "./chunk-FNU4CRJJ.js";
+  Hex64Schema,
+  JsonValueSchema,
+  Money
+} from "./chunk-PDE55ZZV.js";
 
 // src/core/api-client.ts
 var TIMEOUT_MS = 1e4;
@@ -45,15 +50,26 @@ var ApiClient = class {
       "user-agent": userAgent
     };
   }
-  async post(path, body) {
+  post(path, body) {
+    return this.request("POST", path, JSON.stringify(body));
+  }
+  /** A read; `query` entries left undefined are not sent. */
+  get(path, query = {}) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(query))
+      if (value !== void 0) params.set(key, String(value));
+    const search = params.toString();
+    return this.request("GET", search ? `${path}?${search}` : path);
+  }
+  async request(method, path, body) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
     let res;
     try {
       res = await globalThis.fetch(`${this.baseUrl}${path}`, {
-        method: "POST",
+        method,
         headers: this.headers,
-        body: JSON.stringify(body),
+        ...body !== void 0 ? { body } : {},
         signal: controller.signal
       });
     } catch (err) {
@@ -806,9 +822,196 @@ var Streams = class {
   }
 };
 
+// src/x402/headers.ts
+import { z } from "zod";
+var Base64Json = z.string().regex(/^[A-Za-z0-9+/]*={0,2}$/).transform((value, ctx) => {
+  try {
+    return JSON.parse(Buffer.from(value, "base64").toString("utf8"));
+  } catch {
+    ctx.addIssue({ code: "custom", message: "not base64 JSON" });
+    return z.NEVER;
+  }
+});
+var Accepts = z.looseObject({
+  payTo: z.string().optional().catch(void 0),
+  amount: z.string().optional().catch(void 0),
+  network: z.string().optional().catch(void 0),
+  asset: z.string().optional().catch(void 0)
+});
+var PaymentRequired = Base64Json.pipe(
+  z.looseObject({ accepts: z.array(Accepts).optional().catch(void 0) })
+);
+var PaymentPayload = Base64Json.pipe(
+  z.looseObject({
+    accepted: Accepts.optional().catch(void 0),
+    payload: z.record(z.string(), z.unknown()).optional().catch(void 0),
+    extensions: z.record(z.string(), z.unknown()).optional().catch(void 0)
+  })
+);
+var Requirement = z.looseObject({
+  scheme: z.string().min(1),
+  network: z.string().min(1),
+  asset: z.string().min(1),
+  amount: z.string().regex(/^\d+$/),
+  payTo: z.string().min(1),
+  maxTimeoutSeconds: z.number().int().positive().optional()
+});
+var Shape = JsonValueSchema.optional().catch(void 0);
+var Challenge = Base64Json.pipe(
+  z.looseObject({
+    x402Version: z.literal(2),
+    accepts: z.array(z.unknown()),
+    resource: z.looseObject({ url: z.string(), description: z.string().optional().catch(void 0) }).optional().catch(void 0),
+    extensions: z.looseObject({
+      bazaar: z.looseObject({
+        info: z.looseObject({ input: Shape }).optional().catch(void 0),
+        schema: z.looseObject({
+          properties: z.looseObject({ input: Shape }).optional().catch(void 0)
+        }).optional().catch(void 0)
+      }).optional().catch(void 0)
+    }).optional().catch(void 0)
+  })
+).transform((c) => ({
+  resource: c.resource ? { url: c.resource.url, description: c.resource.description } : null,
+  accepts: c.accepts.flatMap((a) => {
+    const r = Requirement.safeParse(a);
+    return r.success ? [r.data] : [];
+  }),
+  input: c.extensions?.bazaar?.info?.input ?? null,
+  inputSchema: c.extensions?.bazaar?.schema?.properties?.input ?? null
+}));
+var Settlement = Base64Json.pipe(
+  z.looseObject({
+    success: z.boolean(),
+    transaction: z.string().optional().catch(void 0),
+    network: z.string().optional().catch(void 0),
+    payer: z.string().optional().catch(void 0),
+    errorReason: z.string().optional().catch(void 0),
+    errorMessage: z.string().optional().catch(void 0)
+  })
+);
+
+// src/x402/x402.ts
+var X402 = class _X402 {
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * x402-payable APIs matching `q`, grouped by vendor, as the platform finds
+   * them live in public catalogs (GAP-90); with `network`, only what can be
+   * paid there. `sources` says which catalogs answered. Null when the
+   * platform could not be reached (GAP-70); a rejected query throws.
+   */
+  async catalog(search) {
+    try {
+      return await this.api.get("/v1/x402/catalog", {
+        q: search.q,
+        network: search.network,
+        limit: search.limit
+      });
+    } catch (err) {
+      if (!Transport.outage(err)) throw err;
+      console.error("[beltic]", err);
+      return null;
+    }
+  }
+  /**
+   * A fetch bound to `session` that records what x402 crosses it. A request
+   * made while the session has no stream (the platform could not open one,
+   * GAP-70) goes through unrecorded.
+   */
+  fetch(session) {
+    return async (input, init) => {
+      const stream = await session.stream();
+      if (!stream) return globalThis.fetch(input, init);
+      const headers = new Headers(
+        init?.headers ?? (input instanceof Request ? input.headers : void 0)
+      );
+      headers.set(SESSION_HEADER, stream.id);
+      const payload = PaymentPayload.safeParse(headers.get("PAYMENT-SIGNATURE")).data;
+      if (payload) {
+        const bound = {
+          ...payload,
+          extensions: { ...payload.extensions, [SESSION_EXTENSION]: stream.id }
+        };
+        headers.set("PAYMENT-SIGNATURE", _X402.encode(bound));
+        await stream.emit("payment.presented", x402Moments.payload(bound));
+        await stream.flush();
+      }
+      const res = await globalThis.fetch(input, { ...init, headers });
+      if (res.status !== 402) return res;
+      const required = PaymentRequired.safeParse(res.headers.get("PAYMENT-REQUIRED")).data;
+      if (required) await stream.emit("payment.requested", x402Moments.required(required));
+      return res;
+    };
+  }
+  /** The unpaid request, sent as it will be paid, and the challenge it answered. */
+  async quote(session, url, request = {}) {
+    const res = await this.fetch(session)(url, _X402.init(request));
+    await res.body?.cancel();
+    if (res.status !== 402) return { status: res.status, challenge: null };
+    const challenge = Challenge.safeParse(res.headers.get("PAYMENT-REQUIRED"));
+    return { status: 402, challenge: challenge.success ? challenge.data : null };
+  }
+  /**
+   * The request, sent as it was quoted, carrying `signed` as an x402 v2
+   * `PAYMENT-SIGNATURE` through `fetch` — so the presentation is recorded,
+   * bound to the session and flushed before it leaves (GAP-66). What the
+   * seller settled is read, not recorded (GAP-77).
+   */
+  async pay(session, url, signed, request = {}) {
+    const payment = {
+      x402Version: 2,
+      resource: { url },
+      accepted: signed.accepted,
+      payload: signed.payload
+    };
+    const response = await this.fetch(session)(
+      url,
+      _X402.init(request, { "PAYMENT-SIGNATURE": _X402.encode(payment) })
+    );
+    const settlement = Settlement.safeParse(response.headers.get("PAYMENT-RESPONSE"));
+    return { response, settlement: settlement.success ? settlement.data : null };
+  }
+  /** An `accepts` entry as the payment `session.decide` takes — the normalization the recorded moments use. */
+  summary(accepts, opts = {}) {
+    return x402Moments.summary(accepts, opts);
+  }
+  /**
+   * The declared intent for an x402 mandate (Fraud SDK RFC › Session ›
+   * `intent.declared`). The cap must be in the currency the rail's moments
+   * carry — `<network>/<asset>`, atomic units (GAP-49) — or the platform's
+   * spend detectors compare two currencies and never meet.
+   */
+  intent(input) {
+    return {
+      mandate: input.mandate,
+      maxAmount: Money.x402(input.network, input.asset, input.maxAmount).toAmount(),
+      validUntil: new Date(input.validUntil).toISOString(),
+      ...input.merchantAllowlist ? { merchantAllowlist: input.merchantAllowlist } : {}
+    };
+  }
+  /** The request as `quote` and `pay` send it: `GET` bare, `POST` with a JSON body, unless told otherwise. */
+  static init(request, extra = {}) {
+    const headers = { accept: "*/*", ...extra };
+    if (request.body === void 0) return { method: request.method ?? "GET", headers };
+    return {
+      method: request.method ?? "POST",
+      headers: { ...headers, "content-type": "application/json" },
+      body: JSON.stringify(request.body)
+    };
+  }
+  /** An x402 header value: base64 of the JSON. */
+  static encode(value) {
+    return Buffer.from(JSON.stringify(value), "utf8").toString("base64");
+  }
+};
+
 // src/client.ts
-var SDK_VERSION = "0.7.0";
+var SDK_VERSION = "0.8.0";
 var Beltic = class _Beltic {
+  /** x402 for the buyer: `catalog`, `fetch`, `quote`, `pay`, `summary`, `intent`. */
+  x402;
   /** The stream registry, for the protocol adapters. @internal */
   streams;
   api;
@@ -841,6 +1044,7 @@ var Beltic = class _Beltic {
       `@belticlabs/agent-risk-sdk/${SDK_VERSION}`
     );
     this.transport = new Transport(this.api);
+    this.x402 = new X402(this.api);
     this.streams = new Streams({
       api: this.api,
       transport: this.transport,
@@ -917,5 +1121,6 @@ export {
   ChainRejectedError,
   Decision,
   SDK_VERSION,
-  Session
+  Session,
+  X402
 };

package/dist/protocol/index.d.ts

@@ -1,5 +1,5 @@
-import { J as JsonValue, E as EvidenceSourceAll, D as Decision } from '../index-DAVKGJs5.js';
-export { A as ALL_SOURCES, a as ApiError, b as ApiErrorSchema, C as ChainHead, c as CreatePolicyInputSchema, d as CreatePolicyOutput, e as CreateSessionInput, f as CreateSessionInputSchema, g as CreateSessionOutput, h as DeclaredIntent, i as DeclaredIntentSchema, j as DigestedEnvelope, k as EvaluateInput, l as EvaluateInputSchema, m as EvaluateOutput, n as EventResult, o as EvidenceAck, p as EvidenceBatchInputSchema, q as EvidenceEnvelope, r as EvidenceEvent, s as EvidenceEventSchema, t as EvidenceKind, u as EvidenceSource, v as EvidenceSourceAllSchema, w as EvidenceSourceSchema, G as GatewayDecisionPayload, H as Hex64, x as Hex64Schema, I as IntentDeclaredPayload, y as JsonObject, z as JsonValueSchema, L as LlmCallEndPayload, B as LlmCallParams, F as LlmCallStartPayload, M as MAX_BATCH_EVENTS, P as PayloadByKind, K as PaymentMomentPayload, N as PaymentSummary, O as PaymentSummarySchema, Q as PlatformAnomalyPayload, R as PlatformEvidenceKind, S as PlatformObservationPayload, T as PromptBase, U as PromptDelta, V as SESSION_ID_CHARS, W as SESSION_ID_PREFIX, X as SOURCE_ORDER, Y as SessionClosePayload, Z as SessionIdSchema, _ as SessionOpenPayload, $ as Sig, a0 as TimestampSchema, a1 as ToolCallEndPayload, a2 as ToolCallStartPayload, a3 as TransportGapPayload, a4 as WireEvidenceKind, a5 as chainKey, a6 as compareByArrival, a7 as compareBySessionSource, a8 as compareBySourceSeq, a9 as compareRootFirst, aa as payloadSchemaFor, ab as withinHeads } from '../index-DAVKGJs5.js';
+import { J as JsonValue, E as EvidenceSourceAll, D as Decision } from '../index-CBUSXzgG.js';
+export { A as ALL_SOURCES, a as ApiError, b as ApiErrorSchema, C as CatalogEndpoint, c as CatalogOffer, d as CatalogOutput, e as CatalogQuery, f as CatalogQuerySchema, g as CatalogSourceReport, h as CatalogVendor, i as ChainHead, j as CreatePolicyInputSchema, k as CreatePolicyOutput, l as CreateSessionInput, m as CreateSessionInputSchema, n as CreateSessionOutput, o as DeclaredIntent, p as DeclaredIntentSchema, q as DigestedEnvelope, r as EvaluateInput, s as EvaluateInputSchema, t as EvaluateOutput, u as EventResult, v as EvidenceAck, w as EvidenceBatchInputSchema, x as EvidenceEnvelope, y as EvidenceEvent, z as EvidenceEventSchema, B as EvidenceKind, F as EvidenceSource, G as EvidenceSourceAllSchema, H as EvidenceSourceSchema, I as GatewayDecisionPayload, K as Hex64, L as Hex64Schema, M as IntentDeclaredPayload, N as JsonObject, O as JsonValueSchema, P as LlmCallEndPayload, Q as LlmCallParams, R as LlmCallStartPayload, S as MAX_BATCH_EVENTS, T as MAX_CATALOG_RESULTS, U as PayloadByKind, V as PaymentMomentPayload, W as PaymentSummary, X as PaymentSummarySchema, Y as PlatformAnomalyPayload, Z as PlatformEvidenceKind, _ as PlatformObservationPayload, $ as PromptBase, a0 as PromptDelta, a1 as SESSION_ID_CHARS, a2 as SESSION_ID_PREFIX, a3 as SOURCE_ORDER, a4 as SessionClosePayload, a5 as SessionIdSchema, a6 as SessionOpenPayload, a7 as Sig, a8 as TimestampSchema, a9 as ToolCallEndPayload, aa as ToolCallStartPayload, ab as TransportGapPayload, ac as WireEvidenceKind, ad as chainKey, ae as compareByArrival, af as compareBySessionSource, ag as compareBySourceSeq, ah as compareRootFirst, ai as payloadSchemaFor, aj as withinHeads } from '../index-CBUSXzgG.js';
 import { z } from 'zod';
 
 /**

package/dist/protocol/index.js

@@ -3,6 +3,7 @@ import {
   ANNOTATION_CODES,
   AmountSchema,
   ApiErrorSchema,
+  CatalogQuerySchema,
   CreatePolicyInputSchema,
   CreateSessionInputSchema,
   DecimalStringSchema,
@@ -16,6 +17,7 @@ import {
   INDICATOR_CODES,
   JsonValueSchema,
   MAX_BATCH_EVENTS,
+  MAX_CATALOG_RESULTS,
   Money,
   PaymentSummarySchema,
   PolicyRulesSchema,
@@ -38,12 +40,13 @@ import {
   payloadSchemaFor,
   walkPath,
   withinHeads
-} from "../chunk-FNU4CRJJ.js";
+} from "../chunk-PDE55ZZV.js";
 export {
   ALL_SOURCES,
   ANNOTATION_CODES,
   AmountSchema,
   ApiErrorSchema,
+  CatalogQuerySchema,
   CreatePolicyInputSchema,
   CreateSessionInputSchema,
   DecimalStringSchema,
@@ -57,6 +60,7 @@ export {
   INDICATOR_CODES,
   JsonValueSchema,
   MAX_BATCH_EVENTS,
+  MAX_CATALOG_RESULTS,
   Money,
   PaymentSummarySchema,
   PolicyRulesSchema,

package/dist/{session-DAN29XoB.d.ts → session-DTIzd1EQ.d.ts}

@@ -1,4 +1,4 @@
-import { m as EvaluateOutput, D as Decision$1, y as JsonObject, n as EventResult, r as EvidenceEvent, u as EvidenceSource, T as PromptBase, a4 as WireEvidenceKind, P as PayloadByKind, J as JsonValue, a2 as ToolCallStartPayload, Y as SessionClosePayload, h as DeclaredIntent, N as PaymentSummary, K as PaymentMomentPayload } from './index-DAVKGJs5.js';
+import { t as EvaluateOutput, D as Decision$1, N as JsonObject, u as EventResult, y as EvidenceEvent, F as EvidenceSource, $ as PromptBase, ac as WireEvidenceKind, U as PayloadByKind, J as JsonValue, aa as ToolCallStartPayload, a4 as SessionClosePayload, o as DeclaredIntent, W as PaymentSummary, V as PaymentMomentPayload } from './index-CBUSXzgG.js';
 
 /**
  * The platform's verdict on one payment as a value the host can ask
@@ -40,6 +40,9 @@ declare class ApiClient {
     private readonly headers;
     constructor(baseUrl: string, apiKey: string, userAgent: string);
     post<T>(path: string, body: unknown): Promise<T>;
+    /** A read; `query` entries left undefined are not sent. */
+    get<T>(path: string, query?: Record<string, string | number | undefined>): Promise<T>;
+    private request;
 }
 
 /**
@@ -377,4 +380,4 @@ declare class Session {
     private static callOf;
 }
 
-export { BelticApiError as B, ChainRejectedError as C, type DecideOptions as D, type HumanDecisionInput as H, Session as S, Decision as a, type SessionOptions as b };
+export { ApiClient as A, BelticApiError as B, ChainRejectedError as C, type DecideOptions as D, type HumanDecisionInput as H, Session as S, Decision as a, type SessionOptions as b };

package/dist/x402/hono.d.ts

@@ -1,9 +1,9 @@
 import { RoutesConfig, x402ResourceServer } from '@x402/core/server';
 import { MiddlewareHandler } from 'hono';
-import { B as Beltic } from '../client-Xn9M58OJ.js';
-import '../index-DAVKGJs5.js';
+import { B as Beltic } from '../client-DFZL4Pt3.js';
+import '../index-CBUSXzgG.js';
 import 'zod';
-import '../session-DAN29XoB.js';
+import '../session-DTIzd1EQ.js';
 
 /** Seller half for hono: `@x402/hono`'s payment middleware with the Beltic hooks attached. */
 

package/dist/x402/hono.js

@@ -1,10 +1,9 @@
 import {
   attachX402
-} from "../chunk-HI656UWG.js";
-import "../chunk-M4I3FGZG.js";
-import "../chunk-FQDHFTVR.js";
-import "../chunk-UXXSE643.js";
-import "../chunk-FNU4CRJJ.js";
+} from "../chunk-P3VZNH5W.js";
+import "../chunk-DI3LZR65.js";
+import "../chunk-MWXXX35V.js";
+import "../chunk-PDE55ZZV.js";
 
 // src/x402/hono.ts
 import {

package/dist/x402/index.d.ts

@@ -1,8 +1,8 @@
 import { x402ResourceServer, x402HTTPResourceServer } from '@x402/core/server';
-import { B as Beltic } from '../client-Xn9M58OJ.js';
-import { S as Session } from '../session-DAN29XoB.js';
-import { h as DeclaredIntent, N as PaymentSummary } from '../index-DAVKGJs5.js';
+import { B as Beltic } from '../client-DFZL4Pt3.js';
+import '../index-CBUSXzgG.js';
 import 'zod';
+import '../session-DTIzd1EQ.js';
 
 declare function attachX402(beltic: Beltic, server: x402ResourceServer, http?: x402HTTPResourceServer): void;
 
@@ -14,59 +14,4 @@ declare function attachX402(beltic: Beltic, server: x402ResourceServer, http?: x
 declare const SESSION_EXTENSION = "beltic.sessionId";
 declare const SESSION_HEADER = "Beltic-Session-Id";
 
-/**
- * The paying fetch, observed. A request made while the session has no
- * stream (the platform could not open one, GAP-70) goes through the inner
- * fetch unrecorded.
- */
-declare function belticFetch(session: Session, inner?: typeof globalThis.fetch): typeof globalThis.fetch;
-
-/**
- * The declared intent for an x402 mandate (Fraud SDK RFC › Session ›
- * `intent.declared`). The cap must be in the currency the rail's moments
- * carry — `<network>/<asset>`, atomic units (GAP-49) — or the platform's
- * spend detectors compare two currencies and never meet; this is the one
- * place a buyer spells that. Everything else is the protocol's own shape.
- */
-
-interface X402IntentInput {
-    mandate: string;
-    network: string;
-    asset: string;
-    /** Atomic units of `asset`, as x402 carries amounts — a decimal string or a bigint, never a float. */
-    maxAmount: string | bigint;
-    validUntil: string | Date;
-    merchantAllowlist?: string[] | undefined;
-}
-declare function x402Intent(input: X402IntentInput): DeclaredIntent;
-
-/**
- * x402 artifacts → protocol moments (Fraud SDK RFC › Protocol Adapter —
- * x402). The moment is normalized (payee, amount, payer) so both sides of
- * a purchase compare; the artifact travels whole in `raw`. For x402 the
- * currency is `<network>/<asset>` (GAP-49) and the value is the atomic
- * amount as the protocol carries it — `x402Summary` gives a buyer the same
- * normalization for the payment it is about to evaluate, so what it asks
- * about and what the wrapper records are one and the same.
- */
-
-/**
- * The minimum an `accepts` entry needs to become a moment; unknown parts
- * are named, never dropped.
- */
-interface AcceptsLike {
-    payTo?: string | undefined;
-    amount?: string | undefined;
-    network?: string | undefined;
-    asset?: string | undefined;
-}
-/**
- * The one normalization of an x402 `accepts` entry: the payment in the
- * shape `evaluate` takes, with the payer as `payerOf` would read it. Every
- * moment below is this plus its artifact and `raw`.
- */
-declare function x402Summary(accepts: AcceptsLike | undefined, opts?: {
-    payer?: string | undefined;
-}): PaymentSummary;
-
-export { type AcceptsLike, SESSION_EXTENSION, SESSION_HEADER, type X402IntentInput, attachX402, belticFetch, x402Intent, x402Summary };
+export { SESSION_EXTENSION, SESSION_HEADER, attachX402 };

package/dist/x402/index.js

@@ -1,86 +1,14 @@
 import {
-  SESSION_EXTENSION,
-  SESSION_HEADER,
-  attachX402,
-  x402Moments,
-  x402Summary
-} from "../chunk-HI656UWG.js";
-import "../chunk-M4I3FGZG.js";
-import "../chunk-FQDHFTVR.js";
-import "../chunk-UXXSE643.js";
+  attachX402
+} from "../chunk-P3VZNH5W.js";
 import {
-  Money
-} from "../chunk-FNU4CRJJ.js";
-
-// src/x402/fetch.ts
-import { z } from "zod";
-var Base64Json = z.string().regex(/^[A-Za-z0-9+/]*={0,2}$/).transform((value, ctx) => {
-  try {
-    return JSON.parse(Buffer.from(value, "base64").toString("utf8"));
-  } catch {
-    ctx.addIssue({ code: "custom", message: "not base64 JSON" });
-    return z.NEVER;
-  }
-});
-var Accepts = z.looseObject({
-  payTo: z.string().optional().catch(void 0),
-  amount: z.string().optional().catch(void 0),
-  network: z.string().optional().catch(void 0),
-  asset: z.string().optional().catch(void 0)
-});
-var PaymentRequired = Base64Json.pipe(
-  z.looseObject({ accepts: z.array(Accepts).optional().catch(void 0) })
-);
-var PaymentPayload = Base64Json.pipe(
-  z.looseObject({
-    accepted: Accepts.optional().catch(void 0),
-    payload: z.record(z.string(), z.unknown()).optional().catch(void 0),
-    extensions: z.record(z.string(), z.unknown()).optional().catch(void 0)
-  })
-);
-function belticFetch(session, inner = globalThis.fetch) {
-  return async (input, init) => {
-    const stream = await session.stream();
-    if (!stream) return inner(input, init);
-    const headers = new Headers(
-      init?.headers ?? (input instanceof Request ? input.headers : void 0)
-    );
-    headers.set(SESSION_HEADER, stream.id);
-    const payload = PaymentPayload.safeParse(headers.get("PAYMENT-SIGNATURE")).data;
-    if (payload) {
-      const bound = {
-        ...payload,
-        extensions: { ...payload.extensions, [SESSION_EXTENSION]: stream.id }
-      };
-      headers.set("PAYMENT-SIGNATURE", encodeHeader(bound));
-      await stream.emit("payment.presented", x402Moments.payload(bound));
-      await stream.flush();
-    }
-    const res = await inner(input, { ...init, headers });
-    if (res.status !== 402) return res;
-    const required = PaymentRequired.safeParse(res.headers.get("PAYMENT-REQUIRED")).data;
-    if (required) await stream.emit("payment.requested", x402Moments.required(required));
-    return res;
-  };
-}
-function encodeHeader(value) {
-  return Buffer.from(JSON.stringify(value), "utf8").toString("base64");
-}
-
-// src/x402/intent.ts
-function x402Intent(input) {
-  return {
-    mandate: input.mandate,
-    maxAmount: Money.x402(input.network, input.asset, input.maxAmount).toAmount(),
-    validUntil: new Date(input.validUntil).toISOString(),
-    ...input.merchantAllowlist ? { merchantAllowlist: input.merchantAllowlist } : {}
-  };
-}
+  SESSION_EXTENSION,
+  SESSION_HEADER
+} from "../chunk-DI3LZR65.js";
+import "../chunk-MWXXX35V.js";
+import "../chunk-PDE55ZZV.js";
 export {
   SESSION_EXTENSION,
   SESSION_HEADER,
-  attachX402,
-  belticFetch,
-  x402Intent,
-  x402Summary
+  attachX402
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@belticlabs/agent-risk-sdk",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "The Beltic Agent Risk SDK — one client, two halves: instrument the buyer agent (AI SDK, x402 fetch) and guard the seller boundary (x402 over hono, evaluate).",
   "license": "UNLICENSED",
   "repository": {

package/dist/chunk-FQDHFTVR.js

@@ -1,29 +0,0 @@
-// src/core/json.ts
-function toJson(value) {
-  if (value === null || value === void 0) return null;
-  if (typeof value === "string" || typeof value === "boolean") return value;
-  if (typeof value === "number") return Number.isFinite(value) ? value : null;
-  if (typeof value === "bigint") return value.toString();
-  if (value instanceof Uint8Array) return { $bytes: Buffer.from(value).toString("base64") };
-  if (value instanceof Date) return value.toISOString();
-  if (value instanceof URL) return value.toString();
-  if (Array.isArray(value)) return value.map(toJson);
-  if (typeof value === "object") {
-    const out = {};
-    for (const [k, v] of Object.entries(value)) {
-      if (v === void 0 || typeof v === "function") continue;
-      out[k] = toJson(v);
-    }
-    return out;
-  }
-  return null;
-}
-function toJsonObject(value) {
-  const j = toJson(value);
-  return j && typeof j === "object" && !Array.isArray(j) ? j : { value: j };
-}
-
-export {
-  toJson,
-  toJsonObject
-};

package/dist/chunk-M4I3FGZG.js

@@ -1,13 +0,0 @@
-// src/core/payment-moment.ts
-function summaryOf(m) {
-  return {
-    protocol: m.protocol,
-    payee: m.payee,
-    amount: { value: m.amount.value, currency: m.amount.currency },
-    ...m.payer ? { payer: m.payer } : {}
-  };
-}
-
-export {
-  summaryOf
-};

package/dist/client-Xn9M58OJ.d.ts

@@ -1,71 +0,0 @@
-import { N as PaymentSummary } from './index-DAVKGJs5.js';
-import { b as SessionOptions, S as Session, a as Decision } from './session-DAN29XoB.js';
-
-/**
- * One SDK, two halves (Fraud SDK RFC › Summary). `Beltic` is the single
- * client: `session` for the buyer half, `evaluate` for whichever half is
- * about to let a payment through. Protocol integrations are plain
- * functions behind subpath exports, each pulling exactly one optional peer:
- *
- *   @belticlabs/agent-risk-sdk/ai    → middleware(session), wrapTools(session, …)
- *   @belticlabs/agent-risk-sdk/x402  → belticFetch(session), x402Summary(…), attachX402(beltic, …)
- *   @belticlabs/agent-risk-sdk/hono  → belticPaymentMiddleware(beltic, …)
- *
- * Neither half decides risk locally: verdicts are platform-side.
- *
- * A client is configured or it is not constructed — `Beltic.fromEnv()`
- * reads `BELTIC_*`, and there is no disabled client (GAP-78). Evidence is
- * a side channel of the work it observes, so a platform outage never
- * throws into that work (GAP-70): the transport waits it out, `session`
- * runs without a stream, `evaluate` answers `Decision.absent()` — never an
- * invented verdict. What the platform *rejects* (a 4xx, a forked chain)
- * is the client's fault and throws.
- */
-
-declare const SDK_VERSION = "0.7.0";
-interface BelticOptions {
-    apiKey: string;
-    baseUrl: string;
-    /** The agent's 32-byte Ed25519 seed as 64 hex — the buyer half. Without it, `session` is unavailable; the seller half works. */
-    agentSeed?: string | undefined;
-}
-declare class Beltic {
-    private readonly api;
-    private readonly transport;
-    /** Open handles by conversation id (GAP-84). */
-    private readonly sessions;
-    /**
-     * The client the environment describes: `BELTIC_API_KEY` and
-     * `BELTIC_BASE_URL`, both required, and `BELTIC_AGENT_SEED` (64 hex) for
-     * the buyer half. A missing required variable is a configuration error,
-     * thrown (GAP-78).
-     */
-    static fromEnv(env?: Record<string, string | undefined>): Beltic;
-    constructor(opts: BelticOptions);
-    /**
-     * A conversation: new without an id, resumed with one — the id `session.id()`
-     * answered in this or any earlier process (GAP-84). One handle per
-     * conversation in-process until it closes; the options count when a
-     * session is opened. See `Session`.
-     */
-    session(id?: string, opts?: SessionOptions): Session;
-    /**
-     * The platform's verdict on a payment — the seller's before it verifies,
-     * the buyer's before it presents (Fraud SDK RFC › Evaluation Client).
-     * Read-your-writes: the session's buffered evidence is flushed first so
-     * the platform judges what the caller already saw (GAP-16/88). With a `callId`
-     * the platform answers the decision already taken for that call anywhere
-     * in the conversation (GAP-84). Absent when the platform could not be
-     * reached (GAP-70).
-     */
-    evaluate(sessionId: string, payment: PaymentSummary, opts?: {
-        callId?: string | undefined;
-    }): Promise<Decision>;
-    /** Send everything buffered now — every session's — and wait for that attempt. */
-    flush(): Promise<void>;
-    shutdown(): Promise<void>;
-    /** `process.env` where there is a `process` (Node); `{}` on workerd, where the shell passes its `env`. */
-    private static processEnv;
-}
-
-export { Beltic as B, SDK_VERSION as S, type BelticOptions as a };