@belticlabs/agent-risk-sdk 0.3.0 → 0.5.0

package/dist/{session-DsBWEP8d.d.ts → session-D9E-efc0.d.ts}

@@ -1,9 +1,9 @@
-import { L as EvidenceAck, G as EventResult, R as EvidenceEvent, B as EvaluateOutput, aB as Verdict, a8 as OnReview, a as PaymentSummary, P as PaymentMomentPayload, D as Decision$1, v as DeclaredIntent, ax as ToolCallStartPayload, b as JsonValue, J as JsonObject, an as SessionClosePayload, V as EvidenceSource, aE as WireEvidenceKind, C as ChainHead, ab as PayloadByKind } from './verdict-6vCyoAHE.js';
+import { w as EventResult, K as EvidenceEvent, u as EvaluateOutput, ax as Verdict, a3 as OnReview, a8 as PaymentSummary, P as PaymentMomentPayload, D as Decision$1, p as DeclaredIntent, at as ToolCallStartPayload, J as JsonValue, Y as JsonObject, aj as SessionClosePayload, O as EvidenceSource, C as ChainHead, aA as WireEvidenceKind, a6 as PayloadByKind } from './verdict-DMnbFuS5.js';
 
 /**
  * The edge signs event digests (Fraud SDK RFC › Modules › Identity Module);
- * the platform signs its own PLATFORM chain and epoch anchors. Both are the
- * same operation over different keys, so one interface.
+ * the platform signs its own PLATFORM chain. Both are the same operation
+ * over different keys, so one interface.
  */
 interface Signer {
     /** Raw 32-byte Ed25519 public key. */
@@ -16,9 +16,8 @@ interface Signer {
 interface ApiClientOptions {
     baseUrl: string;
     apiKey: string;
-    fetch?: typeof globalThis.fetch;
-    timeoutMs?: number;
-    userAgent?: string;
+    fetch?: typeof globalThis.fetch | undefined;
+    userAgent?: string | undefined;
 }
 declare class BelticApiError extends Error {
     readonly status: number;
@@ -26,13 +25,12 @@ declare class BelticApiError extends Error {
     readonly details?: unknown | undefined;
     readonly requestId?: string | undefined;
     constructor(status: number, code: string, message: string, details?: unknown | undefined, requestId?: string | undefined);
-    /** 5xx and network failures are retried by the transport; 4xx are not. */
+    /** 5xx, 429 and network failures are retried by the transport and absorbed by `failOpen`; 4xx are neither (GAP-70). */
     get retryable(): boolean;
 }
 declare class ApiClient {
     private readonly baseUrl;
     private readonly fetchImpl;
-    private readonly timeoutMs;
     private readonly headers;
     constructor(opts: ApiClientOptions);
     post<T>(path: string, body: unknown, headers?: Record<string, string>): Promise<T>;
@@ -40,6 +38,12 @@ declare class ApiClient {
     private request;
 }
 
+/**
+ * Identity Module (Fraud SDK RFC › Modules): the agent's credential (DID +
+ * VC) and the event-signing key. Phase 1 is did:key over Ed25519 (GAP-11):
+ * the DID *is* the public key, so the signer and the identity are one.
+ */
+
 interface AgentIdentity {
     did: string;
     signer: Signer;
@@ -47,28 +51,6 @@ interface AgentIdentity {
     credential?: string;
 }
 declare function identityFromSeed(seed: Uint8Array, credential?: string): AgentIdentity;
-declare function ephemeralIdentity(credential?: string): AgentIdentity;
-/** A JSON keystore on disk: `{ "seed": "<64 hex>" }`, created 0600 when missing. */
-declare function fileIdentity(path: string, credential?: string): AgentIdentity;
-
-/**
- * Correlation without binding (Fraud SDK RFC › Protocol Adapter — x402:
- * "binding travels on the call that initiates the purchase, not
- * necessarily on the payment artifact"). The merchant binds a key it will
- * see again (a checkout session id, a challenge nonce) to the buyer's
- * session; the adapter resolves it when the settlement arrives (GAP-31).
- */
-interface CorrelationStore {
-    bind(key: string, sessionId: string, ttlMs?: number): Promise<void>;
-    resolve(key: string): Promise<string | null>;
-}
-declare class MemoryCorrelationStore implements CorrelationStore {
-    private readonly defaultTtlMs;
-    private readonly entries;
-    constructor(defaultTtlMs?: number);
-    bind(key: string, sessionId: string, ttlMs?: number): Promise<void>;
-    resolve(key: string): Promise<string | null>;
-}
 
 /**
  * Transport (Fraud SDK RFC › Modules: "buffering, batching, chained delivery
@@ -79,8 +61,8 @@ declare class MemoryCorrelationStore implements CorrelationStore {
  * keep chaining onto a head the platform never accepted.
  */
 
-interface TransportOptions {
-    maxBatch: number;
+/** What a host may tune; the defaults are `DEFAULT_TUNING`. */
+interface TransportTuning {
     flushMs: number;
     /** Total buffered events across chains; beyond this new events are dropped (GAP-38). */
     maxBuffered: number;
@@ -89,21 +71,20 @@ interface TransportOptions {
         maxMs: number;
         maxAttempts: number;
     };
-    onAck?: (ack: EvidenceAck) => void;
-    onError?: (err: Error) => void;
-    onChainHalted?: (err: ChainRejectedError) => void;
-    setTimeout?: typeof globalThis.setTimeout;
-    clearTimeout?: typeof globalThis.clearTimeout;
 }
-declare const DEFAULT_TRANSPORT: TransportOptions;
+interface TransportOptions extends TransportTuning {
+    onError?: ((err: Error) => void) | undefined;
+    onChainHalted?: ((err: ChainRejectedError) => void) | undefined;
+}
 declare class ChainRejectedError extends Error {
     readonly sessionId: string;
     readonly source: string;
     readonly result: EventResult;
-    constructor(sessionId: string, source: string, result: EventResult);
-}
-declare class TransportClosedError extends Error {
-    constructor();
+    constructor(sessionId: string, source: string, result: EventResult, options?: {
+        cause?: unknown;
+    });
+    /** Halted by retries exhausted on an outage — not by anything the platform rejected (GAP-70). */
+    get transient(): boolean;
 }
 declare class Transport {
     private readonly api;
@@ -115,6 +96,14 @@ declare class Transport {
     private inFlightCount;
     private drainWaiters;
     constructor(api: ApiClient, opts?: Partial<TransportOptions>);
+    /**
+     * What `failOpen` may absorb (GAP-70): the platform could not be reached
+     * or failed on its side — a network error, a 5xx, a 429, or a chain
+     * halted after exhausting its retries on those. Everything the platform
+     * *rejected* (a 4xx: bad key, unknown session, invalid payload; a `fork`
+     * or `rejected` ack) is a fault of the client and throws in both modes.
+     */
+    static outage(err: unknown): boolean;
     get size(): number;
     hasRoom(): boolean;
     haltedError(sessionId: string, source: string): ChainRejectedError | null;
@@ -139,71 +128,66 @@ declare class Transport {
  *
  *   @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, …)   (and /express)
- *   @belticlabs/agent-risk-sdk/mcp   → wrapClient(session, …), wrapServer(beltic, …)
+ *   @belticlabs/agent-risk-sdk/hono  → belticPaymentMiddleware(beltic, …)
  *
  * Neither half decides risk locally: verdicts are platform-side.
  *
  * A host that runs its own agent loop takes `beltic.run(key)` — a `Run`
  * keyed by its own session id that owns spans, verdicts and the mandate
  * (GAP-79); every integration above accepts a `Run` where it accepts a
- * `Session`. `Beltic.fromEnv()` reads `BELTIC_*` and, when none is set,
- * answers a disabled client that records nothing and never throws into
- * the work (GAP-78), so a host wires Beltic unconditionally.
+ * `Session`. `Beltic.fromEnv()` reads `BELTIC_*`; a client is configured
+ * or it is not constructed — there is no disabled client (GAP-78).
  *
- * Evidence is a side channel of the work it observes. With `failOpen`
- * nothing the SDK does throws into that work: `Session.emit` reports and
+ * Evidence is a side channel of the work it observes. With `failOpen` a
+ * platform outage never throws into that work: `Session.emit` reports and
  * answers `false`, `sessions.open` answers `null`, `evaluate` answers
  * `null` — never an invented verdict; the host decides what to do without
- * one (GAP-70). `sessions.start` and `sessions.ensure` throw either way:
- * they are the primitives the fail-open entries are built on.
+ * one. What the platform *rejects* (a 4xx, a forked chain) is the client's
+ * fault and throws in both modes (GAP-70). `sessions.start` and
+ * `sessions.ensure` throw either way: they are the primitives the fail-open
+ * entries are built on.
  */
 
-declare const SDK_VERSION = "0.3.0";
+declare const SDK_VERSION = "0.5.0";
 type Env = Record<string, string | undefined>;
-interface BelticOptions extends Omit<ApiClientOptions, 'userAgent'> {
-    /** Buyer half. Without it, `sessions.start` is unavailable; the seller half works. */
+interface BelticOptions {
+    apiKey: string;
+    baseUrl: string;
+    fetch?: typeof globalThis.fetch | undefined;
+    /** Buyer half. Without it, `sessions.start` and `open` are unavailable; the seller half works. */
     identity?: AgentIdentity | undefined;
-    transport?: Partial<TransportOptions> | undefined;
+    transport?: Partial<TransportTuning> | undefined;
     /** What a synchronous seller hook does with REVIEW (GAP-52). */
     onReview?: OnReview | undefined;
-    correlation?: CorrelationStore | undefined;
-    redact?: RedactFn | undefined;
-    now?: (() => Date) | undefined;
-    /** Evidence never fails the work it observes; see the module note (GAP-70). */
+    /** A platform outage never fails the work evidence observes; see the module note (GAP-70). */
     failOpen?: boolean | undefined;
-    /** Where fail-open failures go (and transport delivery failures unless `transport` names its own). Default: `console.error`. */
+    /** Where fail-open failures and transport delivery failures go. Default: `console.error`. */
     onError?: ((err: Error) => void) | undefined;
-    /** Fail-open only: how long `sessions.open` answers null after the platform refused to open a session (GAP-71). */
+    /** Fail-open only: how long `sessions.open` answers null after the platform could not open a session (GAP-71). */
     openRetryMs?: number | undefined;
-    /** `false` is what `Beltic.disabled()` sets: no platform is ever called (GAP-78). */
-    enabled?: boolean | undefined;
 }
+/** What `fromEnv` takes besides the environment: everything the variables do not say. */
+type FromEnvOptions = Omit<BelticOptions, 'apiKey' | 'baseUrl' | 'identity'>;
 /** The platform's answer, with the verdict as a value the caller can ask `blocks(onReview)`. */
 type Evaluation = EvaluateOutput & {
     verdict: Verdict;
 };
 declare class Beltic {
-    readonly api: ApiClient;
     readonly transport: Transport;
     readonly sessions: Sessions;
     readonly identity: AgentIdentity | undefined;
-    readonly correlation: CorrelationStore;
     readonly onReview: OnReview;
     readonly failOpen: boolean;
-    /** `false` for a disabled client (GAP-78): nothing is posted, `run`/`sessions.open` answer without a session. */
-    readonly enabled: boolean;
+    private readonly api;
     private readonly onError;
     private readonly runs;
     /**
      * The client the environment describes: `BELTIC_API_KEY`,
      * `BELTIC_BASE_URL`, `BELTIC_AGENT_SEED` (64 hex) and optionally
-     * `BELTIC_AGENT_CREDENTIAL`, fail-open by default. None set → a disabled
-     * client; some set → a configuration error, thrown (GAP-78).
+     * `BELTIC_AGENT_CREDENTIAL`. Any of the three missing is a configuration
+     * error, thrown (GAP-78).
      */
-    static fromEnv(env?: Env, opts?: Partial<BelticOptions>): Beltic;
-    /** A client that records nothing and never throws into the work: the null object for "no evidence stream" (GAP-78). */
-    static disabled(opts?: Partial<BelticOptions>): Beltic;
+    static fromEnv(env?: Env, opts?: FromEnvOptions): Beltic;
     constructor(opts: BelticOptions);
     /**
      * The platform's verdict on a payment — the seller's before it verifies,
@@ -211,7 +195,7 @@ declare class Beltic {
      * is flushed first so the platform judges what the caller already saw
      * (GAP-16). A recorded moment is accepted as is: only its comparable core
      * (payee, amount, payer) is sent. `null` only under `failOpen`, when the
-     * platform could not be asked.
+     * platform could not be reached.
      */
     evaluate(sessionId: string, payment: PaymentSummary | PaymentMomentPayload): Promise<Evaluation | null>;
     private decide;
@@ -225,7 +209,6 @@ declare class Beltic {
     /** `process.env` where there is a `process` (Node); `{}` on workerd, where the shell passes its `env`. */
     private static processEnv;
 }
-declare function createBeltic(opts: BelticOptions): Beltic;
 
 /**
  * The platform's verdict on one payment as a value the host can ask
@@ -347,26 +330,24 @@ declare class Run {
  *
  * `seq` is handed out only when the transport has room for the event
  * (GAP-38): a dropped event never leaves a hole — the next accepted event
- * is preceded by a `transport.gap` that counts the drops. `redact` is off
- * by default (GAP-33).
+ * is preceded by a `transport.gap` that counts the drops. Payloads ship
+ * whole (GAP-33).
  *
  * Evidence is a side channel of the agent's work: with `failOpen` an emit
- * that cannot be chained (halted chain, closed transport) is reported and
- * returns `false` instead of throwing into the model or tool call it
- * observes (GAP-70).
+ * refused because the platform is unreachable is reported and returns
+ * `false` instead of throwing into the model or tool call it observes;
+ * anything the platform rejected still throws (GAP-70).
  */
 
-type RedactFn = (kind: WireEvidenceKind, payload: JsonObject) => JsonObject;
 /** Who created the session — the seller half treats a bound session as buyer-born. */
 type SessionBorn = 'buyer' | 'seller';
 interface SessionDeps {
     transport: Transport;
     signer?: Signer | undefined;
-    redact?: RedactFn | undefined;
     now?: (() => Date) | undefined;
     /** Called once the session closed, so the registry can forget it. */
     onClosed?: ((session: Session) => void) | undefined;
-    /** Report instead of throw when an event cannot be chained (GAP-70). */
+    /** Report instead of throw when the platform is unreachable (GAP-70). */
     failOpen?: boolean | undefined;
     onError?: ((err: Error) => void) | undefined;
 }
@@ -406,7 +387,7 @@ declare class Session {
     /**
      * Resolves once the event is sequenced and buffered — not once it is
      * acknowledged. `false` when the event was dropped, or (fail-open) when
-     * the chain can no longer take it.
+     * the chain halted on an outage.
      */
     emit<K extends WireEvidenceKind>(kind: K, payload: PayloadByKind[K]): Promise<boolean>;
     /** The tool call whose `execute` the host runs itself; see `ToolCallSpan`. */
@@ -429,22 +410,17 @@ interface StartSessionInput {
 /** What `open` sends when it actually opens: a value, or a resolver run only then. */
 type OpenSessionInput = StartSessionInput | (() => StartSessionInput | Promise<StartSessionInput>);
 /** What an integration takes: a session, or the run that owns one — resolved by `Sessions.resolve`. */
-type SessionSource = Session | Run | null | undefined;
+type SessionSource = Session | Run;
 interface SessionsDeps {
     api: ApiClient;
     transport: Transport;
-    /** A disabled client (GAP-78): `open` answers null, `start`/`ensure` throw, nothing is posted. */
-    enabled?: boolean | undefined;
     identity?: AgentIdentity | undefined;
-    redact?: RedactFn | undefined;
-    now?: (() => Date) | undefined;
     sdkVersion: string;
     failOpen?: boolean | undefined;
     onError?: ((err: Error) => void) | undefined;
-    /** Fail-open only: after the platform refused to open a session, `open` resolves null for this long (GAP-71). */
+    /** Fail-open only: after the platform could not open a session, `open` resolves null for this long (GAP-71). */
     openRetryMs?: number | undefined;
 }
-declare const DEFAULT_OPEN_RETRY_MS = 60000;
 declare class Sessions {
     private readonly deps;
     /**
@@ -458,17 +434,18 @@ declare class Sessions {
     private readonly opened;
     private retryAt;
     constructor(deps: SessionsDeps);
-    /** The session behind a source: itself, or the one the run opens (null when there is none). */
+    /** The session behind a source: itself, or the one the run opens (null when the run has none). */
     static resolve(source: SessionSource): Promise<Session | null>;
     /**
      * Buyer half: the evidence session for a key of the host's own (its
      * session, run or conversation id), opened on first use and reused
      * after. A halted chain is reopened as a fresh session that continues
-     * the same key; a closed key is forgotten. When the platform refuses to
-     * open one, a fail-open client resolves null — the host runs without
-     * evidence — until `openRetryMs` has passed (GAP-71); otherwise the
-     * refusal is thrown and the next call tries again. The identity is
-     * required either way: that is configuration.
+     * the same key; a closed key is forgotten. When the platform cannot be
+     * reached, a fail-open client resolves null — the host runs without
+     * evidence — until `openRetryMs` has passed (GAP-71); otherwise, and
+     * whenever the platform refused, the error is thrown and the next call
+     * tries again. The identity is configuration: missing, it throws either
+     * way.
      */
     open(key: string, input?: OpenSessionInput): Promise<Session | null>;
     private forget;
@@ -482,4 +459,4 @@ declare class Sessions {
     private attach;
 }
 
-export { type AgentIdentity as A, Beltic as B, ChainRejectedError as C, DEFAULT_OPEN_RETRY_MS as D, type Env as E, type HumanDecisionInput as H, MemoryCorrelationStore as M, type OpenSessionInput as O, type RedactFn as R, type SessionSource as S, type ToolCallSpan as T, Session as a, ApiClient as b, type ApiClientOptions as c, BelticApiError as d, type BelticOptions as e, type CorrelationStore as f, DEFAULT_TRANSPORT as g, type DecideOptions as h, Decision as i, type Evaluation as j, Run as k, type RunOptions as l, SDK_VERSION as m, type SessionBorn as n, Sessions as o, type StartSessionInput as p, Transport as q, TransportClosedError as r, type TransportOptions as s, createBeltic as t, ephemeralIdentity as u, fileIdentity as v, identityFromSeed as w };
+export { type AgentIdentity as A, Beltic as B, ChainRejectedError as C, type DecideOptions as D, type Env as E, type FromEnvOptions as F, type HumanDecisionInput as H, type OpenSessionInput as O, Run as R, type SessionSource as S, type ToolCallSpan as T, ApiClient as a, type ApiClientOptions as b, BelticApiError as c, type BelticOptions as d, Decision as e, type Evaluation as f, type RunOptions as g, SDK_VERSION as h, Session as i, type SessionBorn as j, Sessions as k, type StartSessionInput as l, Transport as m, type TransportOptions as n, type TransportTuning as o, identityFromSeed as p };

package/dist/{verdict-6vCyoAHE.d.ts → verdict-DMnbFuS5.d.ts}

@@ -318,22 +318,6 @@ declare const EvaluateOutputSchema: z.ZodObject<{
     decisionId: z.ZodUUID;
 }, z.core.$strict>;
 type EvaluateOutput = z.infer<typeof EvaluateOutputSchema>;
-declare const AnchorEntrySchema: z.ZodObject<{
-    epoch: z.ZodString;
-    root: z.ZodString;
-    sig: z.ZodString;
-    chainRef: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-type AnchorEntry = z.infer<typeof AnchorEntrySchema>;
-declare const AnchorsOutputSchema: z.ZodObject<{
-    entries: z.ZodArray<z.ZodObject<{
-        epoch: z.ZodString;
-        root: z.ZodString;
-        sig: z.ZodString;
-        chainRef: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-type AnchorsOutput = z.infer<typeof AnchorsOutputSchema>;
 /** Non-RFC admin surface (GAP-53). */
 declare const CreatePolicyInputSchema: z.ZodObject<{
     rules: z.ZodObject<{
@@ -568,4 +552,4 @@ declare class Verdict {
     effective(onReview: OnReview): Decision;
 }
 
-export { Hex64Schema as $, ALL_SOURCES as A, type EvaluateOutput as B, type ChainHead as C, type Decision as D, type EvidenceSourceAll as E, EvaluateOutputSchema as F, type EventResult as G, EventResultSchema as H, type EventResultStatus as I, type JsonObject as J, EventResultStatusSchema as K, type EvidenceAck as L, EvidenceAckSchema as M, type EvidenceBatchInput as N, EvidenceBatchInputSchema as O, type PaymentMomentPayload as P, type EvidenceEnvelope as Q, type EvidenceEvent as R, EvidenceEventSchema as S, type EvidenceKind as T, EvidenceKindSchema as U, type EvidenceSource as V, EvidenceSourceAllSchema as W, EvidenceSourceSchema as X, type GatewayDecisionPayload as Y, GatewayDecisionPayloadSchema as Z, type Hex64 as _, type PaymentSummary as a, type IntentDeclaredPayload as a0, IntentDeclaredPayloadSchema as a1, JsonValueSchema as a2, type LlmCallEndPayload as a3, LlmCallEndPayloadSchema as a4, type LlmCallStartPayload as a5, LlmCallStartPayloadSchema as a6, MAX_BATCH_EVENTS as a7, type OnReview as a8, PAYMENT_ARTIFACTS as a9, TransportGapPayloadSchema as aA, Verdict as aB, WIRE_KINDS as aC, WIRE_SOURCES as aD, type WireEvidenceKind as aE, WireEvidenceKindSchema as aF, compareBySessionSource as aG, compareBySourceSeq as aH, isPlatformKind as aI, isWireKind as aJ, payloadSchemaFor as aK, PLATFORM_KINDS as aa, type PayloadByKind as ab, PaymentMomentPayloadSchema as ac, PaymentSummarySchema as ad, type PlatformAnomalyPayload as ae, PlatformAnomalyPayloadSchema as af, type PlatformEvidenceKind as ag, PlatformEvidenceKindSchema as ah, type PlatformObservationPayload as ai, PlatformObservationPayloadSchema as aj, SESSION_CLOSE_REASONS as ak, SOURCE_ORDER as al, SeqSchema as am, type SessionClosePayload as an, SessionClosePayloadSchema as ao, SessionIdSchema as ap, type SessionOpenPayload as aq, SessionOpenPayloadSchema as ar, type Sig as as, SigSchema as at, TimestampSchema as au, type ToolCallEndPayload as av, ToolCallEndPayloadSchema as aw, type ToolCallStartPayload as ax, ToolCallStartPayloadSchema as ay, type TransportGapPayload as az, type JsonValue as b, ANOMALY_TYPES as c, type Amount as d, AmountSchema as e, type AnchorEntry as f, AnchorEntrySchema as g, type AnchorsOutput as h, AnchorsOutputSchema as i, type ApiError as j, ApiErrorSchema as k, ChainHeadSchema as l, type CreatePolicyInput as m, CreatePolicyInputSchema as n, type CreatePolicyOutput as o, CreatePolicyOutputSchema as p, type CreateSessionInput as q, CreateSessionInputSchema as r, type CreateSessionOutput as s, CreateSessionOutputSchema as t, DecisionSchema as u, type DeclaredIntent as v, DeclaredIntentSchema as w, type DigestedEnvelope as x, type EvaluateInput as y, EvaluateInputSchema as z };
+export { LlmCallEndPayloadSchema as $, ALL_SOURCES as A, type EvidenceAck as B, type ChainHead as C, type Decision as D, type EvidenceSourceAll as E, EvidenceAckSchema as F, type EvidenceBatchInput as G, EvidenceBatchInputSchema as H, type EvidenceEnvelope as I, type JsonValue as J, type EvidenceEvent as K, EvidenceEventSchema as L, type EvidenceKind as M, EvidenceKindSchema as N, type EvidenceSource as O, type PaymentMomentPayload as P, EvidenceSourceAllSchema as Q, EvidenceSourceSchema as R, type GatewayDecisionPayload as S, GatewayDecisionPayloadSchema as T, type Hex64 as U, Hex64Schema as V, type IntentDeclaredPayload as W, IntentDeclaredPayloadSchema as X, type JsonObject as Y, JsonValueSchema as Z, type LlmCallEndPayload as _, ANOMALY_TYPES as a, type LlmCallStartPayload as a0, LlmCallStartPayloadSchema as a1, MAX_BATCH_EVENTS as a2, type OnReview as a3, PAYMENT_ARTIFACTS as a4, PLATFORM_KINDS as a5, type PayloadByKind as a6, PaymentMomentPayloadSchema as a7, type PaymentSummary as a8, PaymentSummarySchema as a9, type WireEvidenceKind as aA, WireEvidenceKindSchema as aB, compareBySessionSource as aC, compareBySourceSeq as aD, isPlatformKind as aE, isWireKind as aF, payloadSchemaFor as aG, type PlatformAnomalyPayload as aa, PlatformAnomalyPayloadSchema as ab, type PlatformEvidenceKind as ac, PlatformEvidenceKindSchema as ad, type PlatformObservationPayload as ae, PlatformObservationPayloadSchema as af, SESSION_CLOSE_REASONS as ag, SOURCE_ORDER as ah, SeqSchema as ai, type SessionClosePayload as aj, SessionClosePayloadSchema as ak, SessionIdSchema as al, type SessionOpenPayload as am, SessionOpenPayloadSchema as an, type Sig as ao, SigSchema as ap, TimestampSchema as aq, type ToolCallEndPayload as ar, ToolCallEndPayloadSchema as as, type ToolCallStartPayload as at, ToolCallStartPayloadSchema as au, type TransportGapPayload as av, TransportGapPayloadSchema as aw, Verdict as ax, WIRE_KINDS as ay, WIRE_SOURCES as az, type Amount as b, AmountSchema as c, type ApiError as d, ApiErrorSchema as e, ChainHeadSchema as f, type CreatePolicyInput as g, CreatePolicyInputSchema as h, type CreatePolicyOutput as i, CreatePolicyOutputSchema as j, type CreateSessionInput as k, CreateSessionInputSchema as l, type CreateSessionOutput as m, CreateSessionOutputSchema as n, DecisionSchema as o, type DeclaredIntent as p, DeclaredIntentSchema as q, type DigestedEnvelope as r, type EvaluateInput as s, EvaluateInputSchema as t, type EvaluateOutput as u, EvaluateOutputSchema as v, type EventResult as w, EventResultSchema as x, type EventResultStatus as y, EventResultStatusSchema as z };

package/dist/x402/hono.d.ts

@@ -1,11 +1,22 @@
-import { RoutesConfig, x402ResourceServer } from '@x402/core/server';
+import { PaywallConfig, RoutesConfig, x402ResourceServer } from '@x402/core/server';
 import { MiddlewareHandler } from 'hono';
-import { B as Beltic } from '../session-DsBWEP8d.js';
-import { G as GuardedMiddlewareOptions } from '../middleware-9gI0ou2i.js';
-export { a as attachX402 } from '../adapter-BEpzr2R3.js';
-import '../verdict-6vCyoAHE.js';
+import { B as Beltic } from '../session-D9E-efc0.js';
+import { A as AttachOptions } from '../adapter-DEdhsNt-.js';
+export { a as attachX402 } from '../adapter-DEdhsNt-.js';
+import '../verdict-DMnbFuS5.js';
 import 'zod';
 
+/**
+ * The seller half as one middleware: the framework's `@x402/*` payment
+ * middleware over an `x402HTTPResourceServer` with the Beltic hooks
+ * attached. `@belticlabs/agent-risk-sdk/hono` hands in its framework's
+ * `paymentMiddlewareFromHTTPServer`.
+ */
+
+type GuardedMiddlewareOptions = AttachOptions & {
+    paywall?: PaywallConfig | undefined;
+};
+
 /** Seller half for hono: `@x402/hono`'s payment middleware with the Beltic hooks attached. */
 
 declare function belticPaymentMiddleware(beltic: Beltic, routes: RoutesConfig, server: x402ResourceServer, opts?: GuardedMiddlewareOptions): MiddlewareHandler;

package/dist/x402/hono.js

@@ -1,17 +1,23 @@
-import {
-  guardedPaymentMiddleware
-} from "../chunk-NJVO2WIV.js";
 import {
   attachX402
-} from "../chunk-OKC6VMFH.js";
-import "../chunk-FAQ442YH.js";
-import "../chunk-X3W2Z5GC.js";
-import "../chunk-46QN2KEZ.js";
-import "../chunk-LM4NIYE5.js";
+} from "../chunk-GM4KEEZB.js";
 import "../chunk-FQDHFTVR.js";
+import "../chunk-X3W2Z5GC.js";
 
 // src/x402/hono.ts
 import { paymentMiddlewareFromHTTPServer } from "@x402/hono";
+
+// src/x402/middleware.ts
+import {
+  x402HTTPResourceServer
+} from "@x402/core/server";
+function guardedPaymentMiddleware(fromHTTPServer, beltic, routes, server, opts = {}) {
+  const http = new x402HTTPResourceServer(server, routes);
+  attachX402(beltic, server, http, opts);
+  return fromHTTPServer(http, opts.paywall);
+}
+
+// src/x402/hono.ts
 function belticPaymentMiddleware(beltic, routes, server, opts) {
   return guardedPaymentMiddleware(paymentMiddlewareFromHTTPServer, beltic, routes, server, opts);
 }

package/dist/x402/index.d.ts

@@ -1,6 +1,6 @@
-export { A as AttachOptions, b as AttachedX402, C as CorrelationContext, a as attachX402 } from '../adapter-BEpzr2R3.js';
-import { S as SessionSource } from '../session-DsBWEP8d.js';
-import { v as DeclaredIntent, P as PaymentMomentPayload, J as JsonObject, a as PaymentSummary } from '../verdict-6vCyoAHE.js';
+export { A as AttachOptions, b as AttachedX402, a as attachX402 } from '../adapter-DEdhsNt-.js';
+import { S as SessionSource } from '../session-D9E-efc0.js';
+import { p as DeclaredIntent, P as PaymentMomentPayload, Y as JsonObject, a8 as PaymentSummary } from '../verdict-DMnbFuS5.js';
 import '@x402/core/server';
 import 'zod';
 
@@ -14,16 +14,13 @@ import 'zod';
 declare const SESSION_EXTENSION = "beltic.sessionId";
 declare const SESSION_HEADER = "Beltic-Session-Id";
 declare const DECISION_EXTENSION = "beltic.decisionId";
-declare const DECISION_HEADER = "Beltic-Decision-Id";
 declare function sessionIdOf(extensions: Readonly<Record<string, unknown>> | undefined): string | null;
 declare function decisionIdOf(extensions: Readonly<Record<string, unknown>> | undefined): string | null;
 
 /**
- * The paying fetch, observed. Takes a session or the run that owns one;
- * without either (the evidence stream is not configured, or the platform
- * refused to open one) the inner fetch is returned as is — or runs as is
- * per request when the run has no session yet — so a host wires it
- * unconditionally.
+ * The paying fetch, observed. Takes a session or the run that owns one; a
+ * request made while a fail-open run has no session (the platform could
+ * not open one, GAP-70) goes through the inner fetch unrecorded.
  */
 declare function belticFetch(source: SessionSource, inner?: typeof globalThis.fetch): typeof globalThis.fetch;
 
@@ -59,20 +56,19 @@ declare function x402Intent(input: X402IntentInput): DeclaredIntent;
 declare function x402Currency(network: string, asset: string): string;
 /**
  * The minimum an `accepts` entry needs to become a moment; unknown parts
- * are named, never dropped. v1 spells the amount `maxAmountRequired`.
+ * are named, never dropped.
  */
 interface AcceptsLike {
     payTo?: string | undefined;
     amount?: string | undefined;
-    maxAmountRequired?: string | undefined;
     network?: string | undefined;
     asset?: string | undefined;
 }
 /**
- * A 402 challenge and a presented payment of either generation, as far as
- * a moment needs them. `@x402/core`'s `PaymentRequired` and
- * `PaymentPayload` satisfy these structurally, so the seller adapter
- * passes its typed values through and the buyer needs no `@x402/*` types.
+ * A 402 challenge and a presented payment, as far as a moment needs them.
+ * `@x402/core`'s `PaymentRequired` and `PaymentPayload` satisfy these
+ * structurally, so the seller adapter passes its typed values through and
+ * the buyer needs no `@x402/*` types.
  */
 interface PaymentRequiredLike {
     x402Version?: number | undefined;
@@ -81,8 +77,6 @@ interface PaymentRequiredLike {
 interface PaymentPayloadLike {
     x402Version?: number | undefined;
     accepted?: AcceptsLike | undefined;
-    /** v1 names the network here, beside the payload, and nowhere else. */
-    network?: string | undefined;
     payload?: Readonly<Record<string, unknown>> | undefined;
     extensions?: Readonly<Record<string, unknown>> | undefined;
 }
@@ -97,20 +91,14 @@ declare function x402Summary(accepts: AcceptsLike | undefined, opts?: {
 /** The payer is scheme-specific; the common EVM shapes are read, anything else stays in `raw`. */
 declare function payerOf(payload: PaymentPayloadLike): string | undefined;
 declare const x402Moments: {
-    /** The 402 challenge as the buyer saw it, v2 header or v1 body. */
+    /** The 402 challenge as the buyer saw it, from the `PAYMENT-REQUIRED` header. */
     required(required: PaymentRequiredLike): PaymentMomentPayload;
     /** The requirements the seller's resource server resolved for a request. */
     requirements(req: AcceptsLike): PaymentMomentPayload;
     /** A route's static `accepts` config, before any payment header exists. */
     route(route: unknown, raw: JsonObject): PaymentMomentPayload;
-    /** An in-band ask (MRTR `input_required` or a `_meta` envelope) carrying an x402-style `accepts`. */
-    ask(first: AcceptsLike, raw: JsonObject): PaymentMomentPayload;
-    /**
-     * The signed payment the buyer presented. A v2 payload carries the
-     * requirement it accepted; a v1 payload does not, so the caller passes
-     * the `accepts` entry it answered.
-     */
-    payload(payload: PaymentPayloadLike, accepts?: AcceptsLike | undefined): PaymentMomentPayload;
+    /** The signed payment the buyer presented, with the requirement it accepted. */
+    payload(payload: PaymentPayloadLike): PaymentMomentPayload;
 };
 
-export { type AcceptsLike, DECISION_EXTENSION, DECISION_HEADER, type PaymentPayloadLike, type PaymentRequiredLike, SESSION_EXTENSION, SESSION_HEADER, type X402IntentInput, belticFetch, decisionIdOf, payerOf, sessionIdOf, x402Currency, x402Intent, x402Moments, x402Summary };
+export { type AcceptsLike, DECISION_EXTENSION, type PaymentPayloadLike, type PaymentRequiredLike, SESSION_EXTENSION, SESSION_HEADER, type X402IntentInput, belticFetch, decisionIdOf, payerOf, sessionIdOf, x402Currency, x402Intent, x402Moments, x402Summary };