@belticlabs/agent-risk-sdk 0.1.1 → 0.2.0

package/dist/{middleware-D-ejQIoE.d.ts → adapter-CF-cUYSA.d.ts}

@@ -1,7 +1,7 @@
-import { x402ResourceServer, x402HTTPResourceServer, PaywallConfig, RoutesConfig } from '@x402/core/server';
-import { B as Beltic } from './client-NxpD_384.js';
 import { D as Decision } from './index-Bjs3BPPU.js';
-import { c as SessionBorn, S as Session } from './session-B2mfurae.js';
+import { x402ResourceServer, x402HTTPResourceServer } from '@x402/core/server';
+import { B as Beltic } from './client-C-mV_3A0.js';
+import { d as SessionBorn, S as Session } from './session-5TClPLI4.js';
 
 interface CorrelationContext {
     path: string;
@@ -25,16 +25,4 @@ interface AttachedX402 {
 }
 declare function attachX402(beltic: Beltic, server: x402ResourceServer, http?: x402HTTPResourceServer, opts?: AttachOptions): AttachedX402;
 
-/**
- * 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` and `@belticlabs/agent-risk-sdk/express` differ only in
- * which `paymentMiddlewareFromHTTPServer` they hand in.
- */
-
-type GuardedMiddlewareOptions = AttachOptions & {
-    paywall?: PaywallConfig | undefined;
-};
-declare function guardedPaymentMiddleware<M>(fromHTTPServer: (http: x402HTTPResourceServer, paywall?: PaywallConfig) => M, beltic: Beltic, routes: RoutesConfig, server: x402ResourceServer, opts?: GuardedMiddlewareOptions): M;
-
-export { type AttachOptions as A, type CorrelationContext as C, type GuardedMiddlewareOptions as G, attachX402 as a, type AttachedX402 as b, guardedPaymentMiddleware as g };
+export { type AttachOptions as A, type CorrelationContext as C, attachX402 as a, type AttachedX402 as b };

package/dist/ai/index.d.ts

@@ -1,6 +1,6 @@
 import { P as PaymentMomentPayload } from '../index-Bjs3BPPU.js';
 import { LanguageModelMiddleware, Tool, ToolSet } from 'ai';
-import { S as Session } from '../session-B2mfurae.js';
+import { S as Session } from '../session-5TClPLI4.js';
 import 'zod';
 
 interface PaymentMoments {
@@ -12,8 +12,8 @@ interface WrapToolOptions<I = unknown, O = unknown> {
     /** When the tool performs a purchase, map its input/output to the payment moments it produced. */
     payment?: (input: I, output: O) => PaymentMoments | null;
 }
-declare function middleware(session: Session): LanguageModelMiddleware;
-declare function wrapTool<T extends Tool>(session: Session, tool: T, opts?: WrapToolOptions): T;
-declare function wrapTools<T extends ToolSet>(session: Session, tools: T, opts?: Record<string, WrapToolOptions>): T;
+declare function middleware(session: Session | null | undefined): LanguageModelMiddleware;
+declare function wrapTool<T extends Tool>(session: Session | null | undefined, tool: T, opts?: WrapToolOptions): T;
+declare function wrapTools<T extends ToolSet>(session: Session | null | undefined, tools: T, opts?: Record<string, WrapToolOptions>): T;
 
 export { type PaymentMoments, type WrapToolOptions, middleware, wrapTool, wrapTools };

package/dist/ai/index.js

@@ -1,14 +1,14 @@
 import {
   recordCall
-} from "../chunk-5TWO73OD.js";
+} from "../chunk-GSH5APZW.js";
 import {
   uuidv7
 } from "../chunk-SFGM7KOG.js";
+import "../chunk-46QN2KEZ.js";
 import {
   toJson,
   toJsonObject
 } from "../chunk-FQDHFTVR.js";
-import "../chunk-46QN2KEZ.js";
 
 // src/ai/index.ts
 var PARAM_KEYS = [
@@ -24,6 +24,7 @@ var PARAM_KEYS = [
   "stopSequences"
 ];
 function middleware(session) {
+  if (!session) return {};
   return {
     wrapGenerate: ({ doGenerate, params, model }) => recordCall(
       session,
@@ -73,7 +74,7 @@ function middleware(session) {
   };
 }
 function wrapTool(session, tool, opts = {}) {
-  if (!tool.execute) return tool;
+  if (!session || !tool.execute) return tool;
   const original = tool.execute;
   const toolName = opts.name ?? tool.name ?? "tool";
   const execute = (input, options) => recordCall(

package/dist/chunk-GSH5APZW.js

@@ -0,0 +1,39 @@
+// src/core/record.ts
+function errorOf(err) {
+  const e = err;
+  return { name: String(e?.name ?? "Error"), message: String(e?.message ?? err) };
+}
+function openCall(session, kind, callId, start) {
+  const started = Date.now();
+  const opened = session.emit(`${kind}.start`, { callId, ...start });
+  const close = async (outcome) => {
+    await opened;
+    return session.emit(
+      `${kind}.end`,
+      { callId, ...outcome, durationMs: Date.now() - started }
+    );
+  };
+  return {
+    callId,
+    opened,
+    end: (outcome = {}) => close(outcome),
+    fail: (error, outcome = {}) => close({ error: errorOf(error), ...outcome })
+  };
+}
+async function recordCall(session, kind, callId, start, run, end = () => ({})) {
+  const span = openCall(session, kind, callId, start);
+  await span.opened;
+  try {
+    const result = await run();
+    await span.end(await end(result));
+    return result;
+  } catch (err) {
+    await span.fail(err);
+    throw err;
+  }
+}
+
+export {
+  openCall,
+  recordCall
+};

package/dist/{chunk-U5Z5Z2BQ.js → chunk-LM4NIYE5.js}

@@ -6,20 +6,23 @@ import {
 function x402Currency(network, asset) {
   return `${network}/${asset}`;
 }
-function fromAccepts(a, artifact, raw) {
+function x402Summary(accepts, opts = {}) {
+  const payer = opts.payer?.toLowerCase();
   return {
     protocol: "x402",
-    payee: a?.payTo ?? "unknown",
+    payee: accepts?.payTo ?? "unknown",
     amount: {
-      value: a?.amount ?? "0",
-      currency: a ? x402Currency(a.network ?? "unknown", a.asset ?? "unknown") : "unknown"
+      value: accepts?.amount ?? accepts?.maxAmountRequired ?? "0",
+      currency: accepts ? x402Currency(accepts.network ?? "unknown", accepts.asset ?? "unknown") : "unknown"
     },
-    artifact,
-    raw
+    ...payer ? { payer } : {}
   };
 }
+function fromAccepts(a, artifact, raw, payer) {
+  return { ...x402Summary(a, { payer }), artifact, raw };
+}
 function payerOf(payload) {
-  const p = payload.payload;
+  const p = payload.payload ?? {};
   const auth = p.authorization;
   const candidates = [
     auth?.from,
@@ -32,15 +35,13 @@ function payerOf(payload) {
   return typeof hit === "string" ? hit.toLowerCase() : void 0;
 }
 var x402Moments = {
-  /** The 402 challenge as the buyer saw it. */
+  /** The 402 challenge as the buyer saw it, v2 header or v1 body. */
   required(required) {
-    const r = required;
-    return fromAccepts(r.accepts[0], "http-402", toJsonObject(r));
+    return fromAccepts(required.accepts?.[0], "http-402", toJsonObject(required));
   },
   /** The requirements the seller's resource server resolved for a request. */
   requirements(req) {
-    const r = req;
-    return fromAccepts(r, "http-402", toJsonObject(r));
+    return fromAccepts(req, "http-402", toJsonObject(req));
   },
   /** A route's static `accepts` config, before any payment header exists. */
   route(route, raw) {
@@ -61,14 +62,18 @@ var x402Moments = {
   ask(first, raw) {
     return fromAccepts(first, "mrtr-input-required", raw);
   },
-  /** The signed payment the buyer presented. */
-  payload(payload) {
-    const p = payload;
-    const payer = payerOf(p);
-    return {
-      ...fromAccepts(p.accepted, "payment-signature", toJsonObject(p)),
-      ...payer ? { payer } : {}
-    };
+  /**
+   * 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, accepts) {
+    return fromAccepts(
+      accepts ?? payload.accepted,
+      "payment-signature",
+      toJsonObject(payload),
+      payerOf(payload)
+    );
   }
 };
 function priceValue(price) {
@@ -81,6 +86,7 @@ function priceValue(price) {
 
 export {
   x402Currency,
+  x402Summary,
   payerOf,
   x402Moments
 };

package/dist/{chunk-W2OY7QXV.js → chunk-SO6HPRJT.js}

@@ -7,13 +7,7 @@ import {
 } from "./chunk-SFGM7KOG.js";
 import {
   x402Moments
-} from "./chunk-U5Z5Z2BQ.js";
-import {
-  summaryOf
-} from "./chunk-7G5EHNVW.js";
-import {
-  Verdict
-} from "./chunk-46QN2KEZ.js";
+} from "./chunk-LM4NIYE5.js";
 
 // src/x402/adapter.ts
 function attachX402(beltic, server, http, opts = {}) {
@@ -56,16 +50,20 @@ function attachX402(beltic, server, http, opts = {}) {
     const presented = x402Moments.payload(payload);
     await session.emit("payment.presented", presented);
     inFlight.set(payloadDigest(payload), session);
-    const out = await beltic.evaluate(session.id, summaryOf(presented));
+    const out = await beltic.evaluate(session.id, presented);
+    if (!out) return;
     opts.onDecision?.({
       sessionId: session.id,
       decision: out.decision,
       reasonCodes: out.reasonCodes,
       born: session.born
     });
-    const verdict = Verdict.of(out.decision);
-    if (verdict.blocks(beltic.onReview)) {
-      return { abort: true, reason: `BELTIC_${verdict.value}`, message: out.reasonCodes.join(",") };
+    if (out.verdict.blocks(beltic.onReview)) {
+      return {
+        abort: true,
+        reason: `BELTIC_${out.verdict.value}`,
+        message: out.reasonCodes.join(",")
+      };
     }
     return;
   });
@@ -79,17 +77,6 @@ function attachX402(beltic, server, http, opts = {}) {
   return { inFlight };
 }
 
-// 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);
-}
-
 export {
-  attachX402,
-  guardedPaymentMiddleware
+  attachX402
 };

package/dist/chunk-U7HM37CB.js

@@ -0,0 +1,17 @@
+import {
+  attachX402
+} from "./chunk-SO6HPRJT.js";
+
+// 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);
+}
+
+export {
+  guardedPaymentMiddleware
+};

package/dist/client-C-mV_3A0.d.ts

@@ -0,0 +1,91 @@
+import { a as PaymentSummary, P as PaymentMomentPayload, B as EvaluateOutput } from './index-Bjs3BPPU.js';
+import { O as OnReview, V as Verdict } from './verdict-BAahb5po.js';
+import { a as ApiClient, g as Transport, e as Sessions, A as AgentIdentity, b as ApiClientOptions, i as TransportOptions, R as RedactFn } from './session-5TClPLI4.js';
+
+/**
+ * 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>;
+}
+
+/**
+ * One SDK, two halves (Fraud SDK RFC › Summary). `Beltic` is the single
+ * client: sessions and evidence for both halves, `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, …)   (and /express)
+ *   @belticlabs/agent-risk-sdk/mcp   → wrapClient(session, …), wrapServer(beltic, …)
+ *
+ * Neither half decides risk locally: verdicts are platform-side.
+ *
+ * Evidence is a side channel of the work it observes. With `failOpen`
+ * nothing the SDK does 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.
+ */
+
+declare const SDK_VERSION = "0.2.0";
+interface BelticOptions extends Omit<ApiClientOptions, 'userAgent'> {
+    /** Buyer half. Without it, `sessions.start` is unavailable; the seller half works. */
+    identity?: AgentIdentity | undefined;
+    transport?: Partial<TransportOptions> | 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). */
+    failOpen?: boolean | undefined;
+    /** Where fail-open failures go (and transport delivery failures unless `transport` names its own). 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). */
+    openRetryMs?: number | undefined;
+}
+/** 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;
+    private readonly onError;
+    constructor(opts: BelticOptions);
+    /**
+     * The platform's verdict on a payment — the seller's before it verifies,
+     * the buyer's before it presents. Read-your-writes: the buffered evidence
+     * 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.
+     */
+    evaluate(sessionId: string, payment: PaymentSummary | PaymentMomentPayload): Promise<Evaluation | null>;
+    private decide;
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+declare function createBeltic(opts: BelticOptions): Beltic;
+
+export { Beltic as B, type CorrelationStore as C, type Evaluation as E, MemoryCorrelationStore as M, SDK_VERSION as S, type BelticOptions as a, createBeltic as c };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-export { B as Beltic, a as BelticOptions, C as CorrelationStore, M as MemoryCorrelationStore, S as SDK_VERSION, c as createBeltic } from './client-NxpD_384.js';
-import { S as Session } from './session-B2mfurae.js';
-export { A as AgentIdentity, a as ApiClient, b as ApiClientOptions, B as BelticApiError, C as ChainRejectedError, D as DEFAULT_TRANSPORT, R as RedactFn, c as SessionBorn, d as Sessions, e as StartSessionInput, T as Transport, f as TransportClosedError, g as TransportOptions, h as ephemeralIdentity, i as fileIdentity, j as identityFromSeed } from './session-B2mfurae.js';
+export { B as Beltic, a as BelticOptions, C as CorrelationStore, E as Evaluation, M as MemoryCorrelationStore, S as SDK_VERSION, c as createBeltic } from './client-C-mV_3A0.js';
+import { S as Session } from './session-5TClPLI4.js';
+export { A as AgentIdentity, a as ApiClient, b as ApiClientOptions, B as BelticApiError, C as ChainRejectedError, D as DEFAULT_OPEN_RETRY_MS, c as DEFAULT_TRANSPORT, O as OpenSessionInput, R as RedactFn, d as SessionBorn, e as Sessions, f as StartSessionInput, T as ToolCallSpan, g as Transport, h as TransportClosedError, i as TransportOptions, j as ephemeralIdentity, k as fileIdentity, l as identityFromSeed } from './session-5TClPLI4.js';
 import { a as PaymentSummary, J as JsonObject, P as PaymentMomentPayload } from './index-Bjs3BPPU.js';
 import './verdict-BAahb5po.js';
 import 'zod';
@@ -12,15 +12,16 @@ import 'zod';
  * sides of one purchase compare (`EVIDENCE_MISMATCH`, GAP-50).
  */
 
-declare function summaryOf(m: PaymentMomentPayload): PaymentSummary;
+declare function summaryOf(m: PaymentSummary | PaymentMomentPayload): PaymentSummary;
 /** A presentation the seller side saw as a signed payment, in any protocol. */
 declare function presentedFrom(summary: PaymentSummary, raw: JsonObject): PaymentMomentPayload;
 
 /**
  * One instrumented call = a `*.start` event, the work, a `*.end` event
  * carrying the outcome or the error (GAP-07 correlates them by `callId`).
- * The AI middleware, the tool wrapper and the MCP client all record the
- * same way.
+ * `openCall` is the span; `recordCall` runs the work inside one. The AI
+ * middleware, the tool wrapper, the MCP client and a host's own tool loop
+ * (`Session.toolCall`) all record the same way.
  */
 
 type CallKind = 'llm_call' | 'tool_call';

package/dist/index.js

@@ -1,6 +1,7 @@
 import {
+  openCall,
   recordCall
-} from "./chunk-5TWO73OD.js";
+} from "./chunk-GSH5APZW.js";
 import {
   Chain,
   didKeyFromEd25519,
@@ -8,11 +9,13 @@ import {
   memorySigner,
   toHex
 } from "./chunk-SFGM7KOG.js";
+import {
+  Verdict
+} from "./chunk-46QN2KEZ.js";
 import {
   presentedFrom,
   summaryOf
 } from "./chunk-7G5EHNVW.js";
-import "./chunk-46QN2KEZ.js";
 
 // src/core/api-client.ts
 var BelticApiError = class extends Error {
@@ -136,8 +139,26 @@ var Session = class {
   get droppedCount() {
     return this.dropped;
   }
-  /** Resolves once the event is sequenced and buffered — not once it is acknowledged. */
+  /**
+   * 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.
+   */
   async emit(kind, payload) {
+    if (!this.deps.failOpen) return this.chainEvent(kind, payload);
+    try {
+      return await this.chainEvent(kind, payload);
+    } catch (err) {
+      this.deps.onError?.(err);
+      return false;
+    }
+  }
+  /** The tool call whose `execute` the host runs itself; see `ToolCallSpan`. */
+  toolCall(call) {
+    const { callId, ...start } = call;
+    return openCall(this, "tool_call", callId, { transport: "local", ...start });
+  }
+  async chainEvent(kind, payload) {
     const halted = this.deps.transport.haltedError(this.id, this.source);
     if (halted) throw halted;
     const ts = this.now().toISOString();
@@ -186,6 +207,7 @@ var Session = class {
     return run;
   }
 };
+var DEFAULT_OPEN_RETRY_MS = 6e4;
 var Sessions = class {
   constructor(deps) {
     this.deps = deps;
@@ -197,18 +219,65 @@ var Sessions = class {
    * mid-session still loses the head (GAP-67).
    */
   attached = /* @__PURE__ */ new Map();
+  /** Buyer sessions by the host's own key (GAP-71). */
+  opened = /* @__PURE__ */ new Map();
+  retryAt = 0;
+  /**
+   * 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.
+   */
+  open(key, input = {}) {
+    const prior = this.opened.get(key) ?? Promise.resolve(null);
+    const next = prior.catch(() => null).then(
+      (session) => session && !this.deps.transport.haltedError(session.id, session.source) ? session : this.openFresh(input, () => this.forget(key, next))
+    );
+    this.opened.set(key, next);
+    next.catch(() => this.forget(key, next));
+    return next;
+  }
+  forget(key, entry) {
+    if (this.opened.get(key) === entry) this.opened.delete(key);
+  }
+  async openFresh(input, onClosed) {
+    this.identityFor("open");
+    const create = async () => this.create(typeof input === "function" ? await input() : input, onClosed);
+    if (!this.deps.failOpen) return create();
+    if (Date.now() < this.retryAt) return null;
+    try {
+      const session = await create();
+      this.retryAt = 0;
+      return session;
+    } catch (err) {
+      this.retryAt = Date.now() + (this.deps.openRetryMs ?? DEFAULT_OPEN_RETRY_MS);
+      this.deps.onError?.(err);
+      return null;
+    }
+  }
   /** Buyer half: create an AGENT_TRACE session bound to the agent identity, then announce it on the chain. */
-  async start(input = {}) {
+  start(input = {}) {
+    return this.create(input);
+  }
+  identityFor(entry) {
     const identity = this.deps.identity;
     if (!identity)
-      throw new Error("sessions.start needs an agent identity (createBeltic({ identity }))");
+      throw new Error(`sessions.${entry} needs an agent identity (createBeltic({ identity }))`);
+    return identity;
+  }
+  async create(input, onClosed) {
+    const identity = this.identityFor("start");
     const body = {
       source: "AGENT_TRACE",
       agent: { did: identity.did, credential: identity.credential ?? identity.did },
       ...input.intent ? { intent: input.intent } : {}
     };
     const out = await this.deps.api.post("/v1/sessions", body);
-    const session = this.attach(out.sessionId, "AGENT_TRACE", out.expiresAt, "buyer");
+    const session = this.attach(out.sessionId, "AGENT_TRACE", out.expiresAt, "buyer", onClosed);
     await session.emit("session.open", {
       runtime: {
         sdk: "@belticlabs/agent-risk-sdk",
@@ -228,7 +297,7 @@ var Sessions = class {
     });
     return this.attach(out.sessionId, "INTERNAL_NETWORK", out.expiresAt, "seller");
   }
-  attach(id, source, expiresAt, born) {
+  attach(id, source, expiresAt, born, onClosed) {
     const key = `${id}:${source}`;
     const existing = this.attached.get(key);
     if (existing) return existing;
@@ -238,7 +307,12 @@ var Sessions = class {
         signer: source === "AGENT_TRACE" ? this.deps.identity?.signer : void 0,
         redact: this.deps.redact,
         now: this.deps.now,
-        onClosed: () => this.attached.delete(key)
+        failOpen: this.deps.failOpen,
+        onError: this.deps.onError,
+        onClosed: () => {
+          this.attached.delete(key);
+          onClosed?.();
+        }
       },
       id,
       source,
@@ -412,7 +486,7 @@ var Transport = class {
 };
 
 // src/client.ts
-var SDK_VERSION = "0.1.1";
+var SDK_VERSION = "0.2.0";
 var Beltic = class {
   api;
   transport;
@@ -420,28 +494,54 @@ var Beltic = class {
   identity;
   correlation;
   onReview;
+  failOpen;
+  onError;
   constructor(opts) {
+    this.failOpen = opts.failOpen ?? false;
+    this.onError = opts.onError ?? ((err) => console.error("[beltic]", err));
     this.api = new ApiClient({ ...opts, userAgent: `@belticlabs/agent-risk-sdk/${SDK_VERSION}` });
-    this.transport = new Transport(this.api, opts.transport);
+    this.transport = new Transport(this.api, {
+      onError: this.onError,
+      onChainHalted: this.onError,
+      ...opts.transport
+    });
     this.sessions = new Sessions({
       api: this.api,
       transport: this.transport,
       sdkVersion: SDK_VERSION,
       identity: opts.identity,
       redact: opts.redact,
-      now: opts.now
+      now: opts.now,
+      failOpen: this.failOpen,
+      onError: this.onError,
+      openRetryMs: opts.openRetryMs
     });
     this.identity = opts.identity;
     this.correlation = opts.correlation ?? new MemoryCorrelationStore();
     this.onReview = opts.onReview ?? "abort";
   }
-  /** Read-your-writes: the platform must hold the evidence before it judges it (GAP-16). */
+  /**
+   * The platform's verdict on a payment — the seller's before it verifies,
+   * the buyer's before it presents. Read-your-writes: the buffered evidence
+   * 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.
+   */
   async evaluate(sessionId, payment) {
+    const input = { sessionId, payment: summaryOf(payment) };
+    if (!this.failOpen) return this.decide(input);
+    try {
+      return await this.decide(input);
+    } catch (err) {
+      this.onError(err);
+      return null;
+    }
+  }
+  async decide(input) {
     await this.transport.flush();
-    return this.api.post("/v1/evaluate", {
-      sessionId,
-      payment
-    });
+    const out = await this.api.post("/v1/evaluate", input);
+    return { ...out, verdict: Verdict.of(out.decision) };
   }
   flush() {
     return this.transport.flush();
@@ -482,6 +582,7 @@ export {
   Beltic,
   BelticApiError,
   ChainRejectedError,
+  DEFAULT_OPEN_RETRY_MS,
   DEFAULT_TRANSPORT,
   MemoryCorrelationStore,
   SDK_VERSION,

package/dist/mcp/index.d.ts

@@ -1,6 +1,6 @@
 import { a as PaymentSummary, P as PaymentMomentPayload } from '../index-Bjs3BPPU.js';
-import { B as Beltic } from '../client-NxpD_384.js';
-import { S as Session } from '../session-B2mfurae.js';
+import { B as Beltic } from '../client-C-mV_3A0.js';
+import { S as Session } from '../session-5TClPLI4.js';
 import 'zod';
 import '../verdict-BAahb5po.js';
 
@@ -13,7 +13,7 @@ interface CallToolParams {
 interface McpClientLike {
     callTool(params: CallToolParams, ...rest: unknown[]): Promise<unknown>;
 }
-declare function wrapClient<C extends McpClientLike>(session: Session, client: C, opts?: {
+declare function wrapClient<C extends McpClientLike>(session: Session | null | undefined, client: C, opts?: {
     server?: string;
 }): C;
 /**