@belticlabs/agent-risk-sdk 0.4.0 → 0.5.0

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

@@ -1,4 +1,4 @@
-import { G as EvidenceAck, y as EventResult, M as EvidenceEvent, w as EvaluateOutput, ax as Verdict, a4 as OnReview, a as PaymentSummary, P as PaymentMomentPayload, D as Decision$1, r as DeclaredIntent, at as ToolCallStartPayload, b as JsonValue, J as JsonObject, aj as SessionClosePayload, R as EvidenceSource, aA as WireEvidenceKind, C as ChainHead, a7 as PayloadByKind } from './verdict-CDAsxktI.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);
@@ -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;
@@ -146,63 +135,59 @@ declare class Transport {
  * 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.4.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,
@@ -210,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;
@@ -224,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
@@ -346,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;
 }
@@ -405,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`. */
@@ -428,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;
     /**
@@ -457,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;
@@ -481,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-CDAsxktI.d.ts → verdict-DMnbFuS5.d.ts}

@@ -552,4 +552,4 @@ declare class Verdict {
     effective(onReview: OnReview): Decision;
 }
 
-export { type LlmCallEndPayload as $, ALL_SOURCES as A, type EventResultStatus as B, type ChainHead as C, type Decision as D, type EvidenceSourceAll as E, EventResultStatusSchema as F, type EvidenceAck as G, EvidenceAckSchema as H, type EvidenceBatchInput as I, type JsonObject as J, EvidenceBatchInputSchema as K, type EvidenceEnvelope as L, type EvidenceEvent as M, EvidenceEventSchema as N, type EvidenceKind as O, type PaymentMomentPayload as P, EvidenceKindSchema as Q, type EvidenceSource as R, EvidenceSourceAllSchema as S, EvidenceSourceSchema as T, type GatewayDecisionPayload as U, GatewayDecisionPayloadSchema as V, type Hex64 as W, Hex64Schema as X, type IntentDeclaredPayload as Y, IntentDeclaredPayloadSchema as Z, JsonValueSchema as _, type PaymentSummary as a, LlmCallEndPayloadSchema as a0, type LlmCallStartPayload as a1, LlmCallStartPayloadSchema as a2, MAX_BATCH_EVENTS as a3, type OnReview as a4, PAYMENT_ARTIFACTS as a5, PLATFORM_KINDS as a6, type PayloadByKind as a7, PaymentMomentPayloadSchema 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 JsonValue as b, ANOMALY_TYPES as c, type Amount as d, AmountSchema as e, type ApiError as f, ApiErrorSchema as g, ChainHeadSchema as h, type CreatePolicyInput as i, CreatePolicyInputSchema as j, type CreatePolicyOutput as k, CreatePolicyOutputSchema as l, type CreateSessionInput as m, CreateSessionInputSchema as n, type CreateSessionOutput as o, CreateSessionOutputSchema as p, DecisionSchema as q, type DeclaredIntent as r, DeclaredIntentSchema as s, type DigestedEnvelope as t, type EvaluateInput as u, EvaluateInputSchema as v, type EvaluateOutput as w, EvaluateOutputSchema as x, type EventResult as y, EventResultSchema 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,9 +1,9 @@
 import { PaywallConfig, RoutesConfig, x402ResourceServer } from '@x402/core/server';
 import { MiddlewareHandler } from 'hono';
-import { B as Beltic } from '../session-gK51QVAM.js';
-import { A as AttachOptions } from '../adapter-CLy44CD2.js';
-export { a as attachX402 } from '../adapter-CLy44CD2.js';
-import '../verdict-CDAsxktI.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';
 
 /**

package/dist/x402/hono.js

@@ -1,6 +1,6 @@
 import {
   attachX402
-} from "../chunk-WY5ZX4BD.js";
+} from "../chunk-GM4KEEZB.js";
 import "../chunk-FQDHFTVR.js";
 import "../chunk-X3W2Z5GC.js";
 

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-CLy44CD2.js';
-import { S as SessionSource } from '../session-gK51QVAM.js';
-import { r as DeclaredIntent, P as PaymentMomentPayload, J as JsonObject, a as PaymentSummary } from '../verdict-CDAsxktI.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';
 
@@ -18,11 +18,9 @@ declare function sessionIdOf(extensions: Readonly<Record<string, unknown>> | und
 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;
 

package/dist/x402/index.js

@@ -1,7 +1,7 @@
 import {
   Session,
   Sessions
-} from "../chunk-4MG6VNAU.js";
+} from "../chunk-JSE6JQJC.js";
 import {
   DECISION_EXTENSION,
   SESSION_EXTENSION,
@@ -13,14 +13,13 @@ import {
   x402Currency,
   x402Moments,
   x402Summary
-} from "../chunk-WY5ZX4BD.js";
+} from "../chunk-GM4KEEZB.js";
 import "../chunk-FQDHFTVR.js";
 import "../chunk-X3W2Z5GC.js";
 
 // src/x402/fetch.ts
 var BASE64 = /^[A-Za-z0-9+/]*={0,2}$/;
 function belticFetch(source, inner = globalThis.fetch) {
-  if (!source) return inner;
   const run = source instanceof Session ? null : source;
   return async (input, init) => {
     const session = await Sessions.resolve(source);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@belticlabs/agent-risk-sdk",
-  "version": "0.4.0",
+  "version": "0.5.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": {