@belticlabs/agent-risk-sdk 0.4.0 → 0.6.0

package/dist/session-Dcof4UIn.d.ts

@@ -0,0 +1,308 @@
+import { u as EvaluateOutput, D as Decision$1, w as EventResult, K as EvidenceEvent, O as EvidenceSource, ay as WireEvidenceKind, a4 as PayloadByKind, as as ToolCallStartPayload, J as JsonValue, ai as SessionClosePayload, X as JsonObject, p as DeclaredIntent, a7 as PaymentSummary, a5 as PaymentMomentPayload } from './index-IfY4XCvJ.js';
+
+/**
+ * The platform's verdict on one payment as a value the host can ask
+ * questions of (Fraud Engine RFC › API: ALLOW | DENY | REVIEW). `absent`
+ * is the outage case: the platform could not be asked (GAP-70), and no
+ * verdict was invented — the host decides what to do without one. A
+ * `Session` memoizes decisions by the host's call id, so a re-run approval
+ * reads the verdict already given (GAP-79).
+ */
+
+declare class Decision {
+    private readonly output;
+    private static readonly ABSENT;
+    private constructor();
+    static of(output: EvaluateOutput): Decision;
+    static absent(): Decision;
+    get value(): Decision$1 | null;
+    get reasonCodes(): readonly string[];
+    get decisionId(): string | null;
+    get allowed(): boolean;
+    get denied(): boolean;
+    get review(): boolean;
+    get absent(): boolean;
+    /** One sentence for the agent or the person: what Beltic said and why. */
+    explain(): string;
+}
+
+declare class BelticApiError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly details?: unknown | undefined;
+    readonly requestId?: string | undefined;
+    constructor(status: number, code: string, message: string, details?: unknown | undefined, requestId?: string | undefined);
+    /** 5xx, 429 and network failures are an outage: retried by the transport, absorbed by the fail-open entries; 4xx are neither (GAP-70). */
+    get retryable(): boolean;
+}
+declare class ApiClient {
+    private readonly baseUrl;
+    private readonly headers;
+    constructor(baseUrl: string, apiKey: string, userAgent: string);
+    post<T>(path: string, body: unknown): Promise<T>;
+}
+
+/**
+ * The edge signs event digests (Fraud SDK RFC › Modules › Identity Module);
+ * 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. */
+    readonly publicKey: Uint8Array;
+    /** Stable identifier for logs and key rotation; `did:key` for agents. */
+    readonly keyId: string;
+    sign(message: Uint8Array): Promise<Uint8Array>;
+}
+
+/**
+ * Identity Module (Fraud SDK RFC › Modules): the agent's DID 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, both derived from
+ * the 32-byte seed the host configures. The credential presented at session
+ * start is the DID itself until a VC is verified anywhere (GAP-78).
+ */
+
+interface AgentIdentity {
+    did: string;
+    signer: Signer;
+}
+
+/**
+ * Transport (Fraud SDK RFC › Modules: "buffering, batching, chained delivery
+ * to the Collector"). Contract as assumed in GAP-18/38: one FIFO per
+ * chain; at most one batch in flight per chain, so order is preserved;
+ * exponential backoff, without end, on network / 5xx / 429 — an outage is
+ * waited out, never surfaced into the work the evidence observes (GAP-70);
+ * a `fork` or `rejected` ack, or a 4xx, halts the chain and surfaces
+ * `ChainRejectedError` — an SDK must not silently keep chaining onto a
+ * head the platform never accepted. `flush` makes one attempt per chain
+ * now and waits for it, so read-your-writes holds when the platform is up
+ * and a caller is not held hostage when it is down.
+ */
+
+declare class ChainRejectedError extends Error {
+    readonly sessionId: string;
+    readonly source: string;
+    readonly result: EventResult;
+    constructor(sessionId: string, source: string, result: EventResult, options?: {
+        cause?: unknown;
+    });
+}
+declare class Transport {
+    private readonly api;
+    private readonly chains;
+    private buffered;
+    private timer;
+    private closed;
+    constructor(api: ApiClient);
+    /**
+     * What the fail-open entries absorb (GAP-70): the platform could not be
+     * reached or failed on its side — a network error, a 5xx, a 429.
+     * Everything the platform *rejected* (a 4xx: bad key, unknown session,
+     * invalid payload) is a fault of the client and throws.
+     */
+    static outage(err: unknown): boolean;
+    get size(): number;
+    hasRoom(): boolean;
+    haltedError(sessionId: string, source: string): ChainRejectedError | null;
+    /** Callers check `hasRoom()` first and assign `seq` only then (GAP-38). */
+    enqueue(ev: EvidenceEvent): void;
+    /** One attempt per chain, now — a chain waiting out its backoff included; resolves once every attempt settled. */
+    flush(): Promise<void>;
+    close(): Promise<void>;
+    private schedule;
+    private unschedule;
+    /** A chain waiting out its backoff is left alone unless forced: only `flush` cuts a backoff short. */
+    private deliver;
+    /** Batches until the chain drains; a retryable failure schedules the next attempt and returns. */
+    private attempt;
+    private halt;
+}
+
+/**
+ * One evidence stream = one chain per (sessionId, source), built at the edge
+ * (Fraud SDK RFC › Wire contract). The buyer half's AGENT_TRACE stream is
+ * signed by the agent identity; the seller half's INTERNAL_NETWORK stream
+ * is not (GAP-61).
+ *
+ * `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. Payloads ship
+ * whole (GAP-33). An outage never reaches `emit`: the transport waits it
+ * out (GAP-70); what throws here is a chain the platform rejected.
+ */
+
+/** Who created the session — the seller half treats a bound session as buyer-born. */
+type StreamBorn = 'buyer' | 'seller';
+interface StreamDeps {
+    transport: Transport;
+    signer?: Signer | undefined;
+    /** Called once the stream closed, so the registry can forget it. */
+    onClosed?: ((stream: Stream) => void) | undefined;
+}
+/**
+ * One tool call as a span: `tool_call.start` now, `tool_call.end` with the
+ * outcome and the elapsed time when the host reports it.
+ */
+interface ToolCallSpan {
+    readonly callId: string;
+    /** Resolves once `tool_call.start` is sequenced; `end` and `fail` wait for it. */
+    readonly opened: Promise<boolean>;
+    end(outcome?: {
+        output?: JsonValue;
+    }): Promise<boolean>;
+    fail(error: unknown, outcome?: {
+        output?: JsonValue;
+    }): Promise<boolean>;
+}
+declare class Stream {
+    private readonly deps;
+    readonly id: string;
+    readonly source: EvidenceSource;
+    readonly born: StreamBorn;
+    private chain;
+    private building;
+    private dropped;
+    private droppedFirstTs;
+    private droppedLastTs;
+    private closed;
+    constructor(deps: StreamDeps, id: string, source: EvidenceSource, born: StreamBorn);
+    get isClosed(): boolean;
+    /**
+     * Resolves once the event is sequenced and buffered — not once it is
+     * acknowledged. `false` when the event was dropped for lack of room.
+     */
+    emit<K extends WireEvidenceKind>(kind: K, payload: PayloadByKind[K]): Promise<boolean>;
+    /** The tool call whose `execute` the host runs itself; see `ToolCallSpan`. */
+    toolCall(call: ToolCallStartPayload): ToolCallSpan;
+    close(reason?: SessionClosePayload['reason'], extra?: JsonObject): Promise<void>;
+    /** Read-your-writes: the platform must hold the evidence before anyone judges it (GAP-16/66). */
+    flush(): Promise<void>;
+    /** Serialized: two concurrent emits get consecutive seqs, never the same one. */
+    private next;
+}
+
+/**
+ * The registry of evidence streams, one object per (session, source) per
+ * process: a chain's head lives in it, so two objects for the same chain
+ * would both start at seq 0 and fork it. Closed streams are forgotten; a
+ * process restart mid-session still loses the head (GAP-67).
+ *
+ * The buyer half opens AGENT_TRACE sessions keyed by the host's own id
+ * (GAP-71) and announces them with `session.open` (seq 0) and
+ * `intent.declared` (seq 1; GAP-23/60). A session the platform could not
+ * open — an outage — resolves `null` for every key during `OPEN_RETRY_MS`,
+ * so the host runs without evidence instead of paying a failed request on
+ * every step (GAP-70); a refused one (4xx) throws, and the next call tries
+ * again. The seller half attaches to a bound session or opens its own
+ * INTERNAL_NETWORK one (GAP-13).
+ */
+
+interface StartInput {
+    intent?: DeclaredIntent | undefined;
+    runtime?: {
+        framework?: string;
+        model?: string;
+    } | undefined;
+    attestations?: JsonObject | undefined;
+}
+interface StreamsDeps {
+    api: ApiClient;
+    transport: Transport;
+    identity: AgentIdentity | null;
+    sdkVersion: string;
+}
+declare class Streams {
+    private readonly deps;
+    private readonly attached;
+    /** Buyer streams by the host's own key (GAP-71). */
+    private readonly opened;
+    private retryAt;
+    constructor(deps: StreamsDeps);
+    /**
+     * Buyer half: the stream for a key of the host's own, 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.
+     */
+    open(key: string, input?: StartInput): Promise<Stream | null>;
+    /** Seller half: emit INTERNAL_NETWORK evidence into a session the buyer bound, or open a seller-born one. */
+    ensure(sessionId?: string | null): Promise<Stream>;
+    private forget;
+    private openFresh;
+    private create;
+    private attach;
+}
+
+interface SessionOptions extends StartInput {
+    /** Close the session (`expired`) after this long without evidence; unset = only the host closes. */
+    idleMs?: number | undefined;
+}
+interface HumanDecisionInput {
+    /** Whether the person let the call proceed. */
+    allowed: boolean;
+    /** The host's own word for what happened: `approved`, `answered`, `rejected`, `cancelled`… */
+    outcome: string;
+    responder?: string | undefined;
+    /** The host's record of what was asked and chosen — a black box to the platform (GAP-75). */
+    record?: JsonObject | undefined;
+}
+interface DecideOptions {
+    /** The host's id for the call the verdict applies to: memoizes the decision and links it to the span. */
+    callId?: string | undefined;
+    /** The mandate as of now; declared first when it differs from the last one. */
+    intent?: DeclaredIntent | undefined;
+}
+interface SessionDeps {
+    streams: Streams;
+    evaluate: (sessionId: string, payment: PaymentSummary) => Promise<Decision>;
+    /** Called once the session closed, so the registry forgets it. */
+    onClosed: (session: Session) => void;
+}
+declare class Session {
+    private readonly deps;
+    readonly key: string;
+    private readonly opts;
+    private opened;
+    private current;
+    /** JCS hash of the mandate on the chain, and of the one the options carried. */
+    private declared;
+    private readonly openedWith;
+    private closed;
+    private timer;
+    private readonly calls;
+    private readonly decisions;
+    constructor(deps: SessionDeps, key: string, opts?: SessionOptions);
+    /** The platform's id for this session — opened on first use, `null` while there is none. */
+    id(): Promise<string | null>;
+    /**
+     * The platform's verdict on a payment about to be presented. Asked once
+     * per call id: a host that re-runs its approval step reads the same
+     * `Decision`. An absent verdict is not memoized, so the next attempt
+     * asks again.
+     */
+    decide(payment: PaymentSummary | PaymentMomentPayload, opts?: DecideOptions): Promise<Decision>;
+    /** The decision given for a call id, or absent. */
+    decision(callId: string): Decision;
+    /** A tool call the host runs itself, reported as two events by its own call id. */
+    readonly tools: {
+        start: (call: ToolCallStartPayload) => Promise<boolean>;
+        end: (callId: string, outcome?: {
+            output?: JsonValue;
+        }) => Promise<boolean>;
+        fail: (callId: string, error: unknown, outcome?: {
+            output?: JsonValue;
+        }) => Promise<boolean>;
+    };
+    /** A person's answer about a call, as the decision it was (GAP-75). */
+    humanDecided(callId: string, input: HumanDecisionInput): Promise<boolean>;
+    close(reason?: SessionClosePayload['reason']): Promise<void>;
+    /** `intent.declared`, unless the mandate is the one already on the chain (GAP-76). */
+    private declare;
+    private take;
+    private touch;
+    private static hash;
+    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 };

package/dist/x402/hono.d.ts

@@ -1,24 +1,13 @@
-import { PaywallConfig, RoutesConfig, x402ResourceServer } from '@x402/core/server';
+import { 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 '../client-CgCjOrRP.js';
+export { a as attachX402 } from '../adapter-AjCgj-KM.js';
+import '../index-IfY4XCvJ.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;
-};
+import '../session-Dcof4UIn.js';
 
 /** 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;
+declare function belticPaymentMiddleware(beltic: Beltic, routes: RoutesConfig, server: x402ResourceServer): MiddlewareHandler;
 
 export { belticPaymentMiddleware };

package/dist/x402/hono.js

@@ -1,25 +1,19 @@
 import {
   attachX402
-} from "../chunk-WY5ZX4BD.js";
+} from "../chunk-IUWC6HT5.js";
+import "../chunk-M4I3FGZG.js";
 import "../chunk-FQDHFTVR.js";
-import "../chunk-X3W2Z5GC.js";
+import "../chunk-77D74TWX.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 = {}) {
+import { paymentMiddlewareFromHTTPServer } from "@x402/hono";
+function belticPaymentMiddleware(beltic, routes, server) {
   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);
+  attachX402(beltic, server, http);
+  return paymentMiddlewareFromHTTPServer(http);
 }
 export {
   attachX402,

package/dist/x402/index.d.ts

@@ -1,30 +1,40 @@
-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 attachX402 } from '../adapter-AjCgj-KM.js';
+import { S as Session } from '../session-Dcof4UIn.js';
+import { p as DeclaredIntent, a7 as PaymentSummary } from '../index-IfY4XCvJ.js';
 import '@x402/core/server';
+import '../client-CgCjOrRP.js';
 import 'zod';
 
 /**
  * Session binding on the x402 rail (Fraud SDK RFC › Protocol Adapter — x402:
  * "`PAYMENT-SIGNATURE` extension `beltic.sessionId`"). Where exactly it
  * lives is GAP-30; that it is outside the wallet-signed payload is GAP-56.
- * A presentation the buyer had evaluated first also carries the
- * `decisionId` the platform answered with, next to the session (GAP-80).
  */
 declare const SESSION_EXTENSION = "beltic.sessionId";
 declare const SESSION_HEADER = "Beltic-Session-Id";
-declare const DECISION_EXTENSION = "beltic.decisionId";
-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.
+ * Buyer half › the x402 fetch wrapper. Sits *inside* the agent's paying
+ * fetch (e.g. `wrapFetchWithPayment(belticFetch(session))`), so it sees the
+ * 402 challenge → `payment.requested`, and the retry carrying the payment
+ * → `payment.presented`, into which it injects the session binding
+ * (GAP-30). It never pays and never decides.
+ *
+ * Before a request that presents payment leaves, the buffered evidence is
+ * flushed: the seller will evaluate as soon as it sees the payment, and
+ * the platform must already hold the buyer's side of the story (GAP-66).
+ *
+ * Only x402 v2 is read — `PAYMENT-REQUIRED` header, `PAYMENT-SIGNATURE`
+ * retry, binding in `extensions` (GAP-72). The header codec is base64
+ * JSON, kept here so a buyer needs no `@x402/*` package to be observed.
  */
-declare function belticFetch(source: SessionSource, inner?: typeof globalThis.fetch): typeof globalThis.fetch;
+
+/**
+ * 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 ›
@@ -55,7 +65,6 @@ declare function x402Intent(input: X402IntentInput): DeclaredIntent;
  * about and what the wrapper records are one and the same.
  */
 
-declare function x402Currency(network: string, asset: string): string;
 /**
  * The minimum an `accepts` entry needs to become a moment; unknown parts
  * are named, never dropped.
@@ -66,22 +75,6 @@ interface AcceptsLike {
     network?: string | undefined;
     asset?: string | undefined;
 }
-/**
- * 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;
-    accepts?: readonly AcceptsLike[] | undefined;
-}
-interface PaymentPayloadLike {
-    x402Version?: number | undefined;
-    accepted?: AcceptsLike | undefined;
-    payload?: Readonly<Record<string, unknown>> | undefined;
-    extensions?: Readonly<Record<string, unknown>> | 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
@@ -90,17 +83,5 @@ interface PaymentPayloadLike {
 declare function x402Summary(accepts: AcceptsLike | undefined, opts?: {
     payer?: string | undefined;
 }): PaymentSummary;
-/** 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, 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;
-    /** The signed payment the buyer presented, with the requirement it accepted. */
-    payload(payload: PaymentPayloadLike): PaymentMomentPayload;
-};
 
-export { type AcceptsLike, DECISION_EXTENSION, type PaymentPayloadLike, type PaymentRequiredLike, SESSION_EXTENSION, SESSION_HEADER, type X402IntentInput, belticFetch, decisionIdOf, payerOf, sessionIdOf, x402Currency, x402Intent, x402Moments, x402Summary };
+export { type AcceptsLike, SESSION_EXTENSION, SESSION_HEADER, type X402IntentInput, belticFetch, x402Intent, x402Summary };

package/dist/x402/index.js

@@ -1,55 +1,40 @@
 import {
-  Session,
-  Sessions
-} from "../chunk-4MG6VNAU.js";
-import {
-  DECISION_EXTENSION,
   SESSION_EXTENSION,
   SESSION_HEADER,
   attachX402,
-  decisionIdOf,
-  payerOf,
-  sessionIdOf,
   x402Currency,
   x402Moments,
   x402Summary
-} from "../chunk-WY5ZX4BD.js";
+} from "../chunk-IUWC6HT5.js";
+import "../chunk-M4I3FGZG.js";
 import "../chunk-FQDHFTVR.js";
-import "../chunk-X3W2Z5GC.js";
+import "../chunk-77D74TWX.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;
+function belticFetch(session, inner = globalThis.fetch) {
   return async (input, init) => {
-    const session = await Sessions.resolve(source);
-    if (!session) return inner(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, session.id);
+    headers.set(SESSION_HEADER, stream.id);
     const signature = headers.get("PAYMENT-SIGNATURE");
     const payload = signature ? decodeHeader(signature) : null;
     if (payload) {
-      const decision = run?.decisionFor(x402Moments.payload(payload));
-      const decisionId = decision && !decision.absent ? decision.decisionId : null;
       const bound = {
         ...payload,
-        extensions: {
-          ...payload.extensions,
-          [SESSION_EXTENSION]: session.id,
-          ...decisionId ? { [DECISION_EXTENSION]: decisionId } : {}
-        }
+        extensions: { ...payload.extensions, [SESSION_EXTENSION]: stream.id }
       };
       headers.set("PAYMENT-SIGNATURE", encodeHeader(bound));
-      await session.emit("payment.presented", x402Moments.payload(bound));
-      await session.flush();
+      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 = challengeOf(res);
-    if (required) await session.emit("payment.requested", x402Moments.required(required));
+    if (required) await stream.emit("payment.requested", x402Moments.required(required));
     return res;
   };
 }
@@ -83,16 +68,10 @@ function x402Intent(input) {
   };
 }
 export {
-  DECISION_EXTENSION,
   SESSION_EXTENSION,
   SESSION_HEADER,
   attachX402,
   belticFetch,
-  decisionIdOf,
-  payerOf,
-  sessionIdOf,
-  x402Currency,
   x402Intent,
-  x402Moments,
   x402Summary
 };

package/package.json

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

@@ -1,29 +0,0 @@
-import { D as Decision } from './verdict-CDAsxktI.js';
-import { x402ResourceServer, x402HTTPResourceServer } from '@x402/core/server';
-import { B as Beltic, n as SessionBorn, a as Session } from './session-gK51QVAM.js';
-
-interface CorrelationContext {
-    path: string;
-    method: string;
-    header: (name: string) => string | undefined;
-}
-interface AttachOptions {
-    /** A key the merchant will see again at verify time, for delegated flows (GAP-31). */
-    correlate?: ((ctx: CorrelationContext) => string | null) | undefined;
-    /** Called with every decision; the default logs nothing. */
-    onDecision?: ((d: {
-        sessionId: string;
-        decision: Decision;
-        reasonCodes: string[];
-        born: SessionBorn;
-        /** The verdict the buyer says it obtained before presenting (GAP-80), unverified. */
-        buyerDecisionId: string | null;
-    }) => void) | undefined;
-}
-interface AttachedX402 {
-    /** Sessions resolved at verify time, keyed by payment digest — for tests and settle hooks. */
-    readonly inFlight: ReadonlyMap<string, Session>;
-}
-declare function attachX402(beltic: Beltic, server: x402ResourceServer, http?: x402HTTPResourceServer, opts?: AttachOptions): AttachedX402;
-
-export { type AttachOptions as A, type CorrelationContext as C, attachX402 as a, type AttachedX402 as b };