@belticlabs/agent-risk-sdk 0.1.0 → 0.2.0

package/dist/adapter-CF-cUYSA.d.ts

@@ -0,0 +1,28 @@
+import { D as Decision } from './index-Bjs3BPPU.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;
+    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;
+    }) => 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 };

package/dist/ai/index.d.ts

@@ -1,7 +1,7 @@
-import { PaymentMomentPayload } from './api.js';
+import { P as PaymentMomentPayload } from '../index-Bjs3BPPU.js';
 import { LanguageModelMiddleware, Tool, ToolSet } from 'ai';
-import { S as Session } from '../session-BMNB1N1g.js';
-import './base58.js';
+import { S as Session } from '../session-5TClPLI4.js';
+import 'zod';
 
 interface PaymentMoments {
     requested?: PaymentMomentPayload;
@@ -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-GCKCAKHA.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-GCKCAKHA.js → chunk-46QN2KEZ.js}

@@ -1,39 +1,20 @@
-// ../protocol/src/verdict.ts
-var SEVERITY = { ALLOW: 0, REVIEW: 1, DENY: 2 };
-var Verdict = class _Verdict {
-  constructor(value) {
-    this.value = value;
-  }
-  static ALLOW = new _Verdict("ALLOW");
-  static REVIEW = new _Verdict("REVIEW");
-  static DENY = new _Verdict("DENY");
-  static of(value) {
-    return value === "DENY" ? _Verdict.DENY : value === "REVIEW" ? _Verdict.REVIEW : _Verdict.ALLOW;
-  }
-  /** The more severe of the two. */
-  atLeast(other) {
-    const o = typeof other === "string" ? _Verdict.of(other) : other;
-    return SEVERITY[o.value] > SEVERITY[this.value] ? o : this;
-  }
-  /** Whether a synchronous gate must stop the call (GAP-52). */
-  blocks(onReview) {
-    return this.value === "DENY" || this.value === "REVIEW" && onReview === "abort";
-  }
-  /** What the gate effectively did: DENY when it blocked, else the verdict itself. */
-  effective(onReview) {
-    return this.blocks(onReview) ? "DENY" : this.value;
-  }
-};
-
-// ../protocol/src/api.ts
-import { z as z4 } from "zod";
-
 // ../protocol/src/evidence.ts
 import { z } from "zod";
 var WIRE_SOURCES = ["AGENT_TRACE", "INTERNAL_NETWORK"];
 var ALL_SOURCES = ["AGENT_TRACE", "INTERNAL_NETWORK", "PLATFORM"];
 var EvidenceSourceSchema = z.enum(WIRE_SOURCES);
 var EvidenceSourceAllSchema = z.enum(ALL_SOURCES);
+var SOURCE_ORDER = {
+  AGENT_TRACE: 0,
+  INTERNAL_NETWORK: 1,
+  PLATFORM: 2
+};
+function compareBySourceSeq(a, b) {
+  return SOURCE_ORDER[a.source] - SOURCE_ORDER[b.source] || a.seq - b.seq;
+}
+function compareBySessionSource(a, b) {
+  return a.sessionId < b.sessionId ? -1 : a.sessionId > b.sessionId ? 1 : SOURCE_ORDER[a.source] - SOURCE_ORDER[b.source];
+}
 var WIRE_KINDS = [
   "session.open",
   "session.close",
@@ -76,11 +57,42 @@ var EvidenceEventSchema = z.strictObject({
   prevHash: Hex64Schema,
   sig: SigSchema.optional()
 });
-
-// ../protocol/src/policy.ts
-import { z as z3 } from "zod";
+function isWireKind(kind) {
+  return WIRE_KINDS.includes(kind);
+}
+function isPlatformKind(kind) {
+  return PLATFORM_KINDS.includes(kind);
+}
 
 // ../protocol/src/reason-codes.ts
+var INDICATOR_CODES = [
+  "CHAIN_BROKEN",
+  "EVIDENCE_MISMATCH",
+  "CREDENTIAL_REVOKED",
+  "SESSION_INVALID",
+  "PRINCIPAL_FLAGGED"
+];
+var ANNOTATION_CODES = ["NO_AGENT_TRACE", "NO_POLICY"];
+var COLLECTOR_CODES = [
+  "SCHEMA_INVALID",
+  "SESSION_UNKNOWN",
+  "SESSION_CLOSED",
+  "SESSION_EXPIRED",
+  "SOURCE_FORBIDDEN",
+  "KIND_FORBIDDEN",
+  "SEQ_GAP",
+  "PREV_HASH_MISMATCH",
+  "SIG_MISSING",
+  "SIG_INVALID",
+  "PAYLOAD_INVALID",
+  "EVENT_TOO_LARGE"
+];
+var DEFAULT_RULE_CODES = [
+  "CAP_EXCEEDED",
+  "PAYEE_NOT_ALLOWED",
+  "NO_INTENT",
+  "INTENT_EXPIRED"
+];
 var REASON_CODE_PATTERN = /^[A-Z][A-Z0-9_]{1,63}$/;
 
 // ../protocol/src/selector.ts
@@ -180,6 +192,40 @@ function parseSelector(input) {
     "unknown root (payment | intent | session | signal[name=\u2026] | evidence[\u2026])"
   );
 }
+function formatSelector(sel) {
+  const path = sel.path.map((p) => "key" in p ? `.${p.key}` : `[${p.index}]`).join("");
+  switch (sel.root) {
+    case "payment":
+    case "intent":
+    case "session":
+      return `${sel.root}${path}`;
+    case "signal":
+      return `signal[name=${sel.name}]${path}`;
+    case "evidence":
+      if (sel.kind === "*") return `evidence[*]${path}`;
+      return `evidence[kind=${sel.kind}${sel.source ? `,source=${sel.source}` : ""}]${sel.all ? "[*]" : ""}${path}`;
+  }
+}
+function isSelectorRef(value) {
+  return typeof value === "string" && value.startsWith("@") && value.length > 1;
+}
+function parseSelectorRef(ref) {
+  return parseSelector(ref.slice(1));
+}
+function walkPath(value, path) {
+  let cur = value;
+  for (const seg of path) {
+    if (cur === null || cur === void 0) return void 0;
+    if ("key" in seg) {
+      if (typeof cur !== "object" || Array.isArray(cur)) return void 0;
+      cur = cur[seg.key];
+    } else {
+      if (!Array.isArray(cur)) return void 0;
+      cur = cur[seg.index];
+    }
+  }
+  return cur;
+}
 var SelectorStringSchema = z2.string().refine(
   (s) => {
     try {
@@ -193,6 +239,7 @@ var SelectorStringSchema = z2.string().refine(
 );
 
 // ../protocol/src/policy.ts
+import { z as z3 } from "zod";
 var PRIMITIVES = ["THRESHOLD", "MEMBERSHIP", "MATCH", "PRESENCE", "FRESHNESS"];
 var PrimitiveSchema = z3.enum(PRIMITIVES);
 var RuleVerdictSchema = z3.enum(["DENY", "REVIEW"]);
@@ -216,6 +263,7 @@ var PolicyRulesSchema = z3.strictObject({
 });
 
 // ../protocol/src/api.ts
+import { z as z4 } from "zod";
 var AmountSchema = z4.strictObject({
   /** Decimal string — never a float. For x402 this is the atomic amount (GAP-49). */
   value: z4.string().regex(/^\d+(\.\d+)?$/, "expected a decimal string"),
@@ -395,7 +443,125 @@ var PlatformAnomalyPayloadSchema = z5.looseObject({
   seq: z5.number().int().min(0).nullable(),
   detail: JsonRecord
 });
+var REGISTRY = {
+  "session.open": SessionOpenPayloadSchema,
+  "session.close": SessionClosePayloadSchema,
+  "intent.declared": IntentDeclaredPayloadSchema,
+  "llm_call.start": LlmCallStartPayloadSchema,
+  "llm_call.end": LlmCallEndPayloadSchema,
+  "tool_call.start": ToolCallStartPayloadSchema,
+  "tool_call.end": ToolCallEndPayloadSchema,
+  "payment.requested": PaymentMomentPayloadSchema,
+  "payment.presented": PaymentMomentPayloadSchema,
+  "gateway.decision": GatewayDecisionPayloadSchema,
+  "transport.gap": TransportGapPayloadSchema,
+  "platform.observation": PlatformObservationPayloadSchema,
+  "platform.anomaly": PlatformAnomalyPayloadSchema
+};
+function payloadSchemaFor(kind) {
+  return REGISTRY[kind];
+}
+
+// ../protocol/src/verdict.ts
+var SEVERITY = { ALLOW: 0, REVIEW: 1, DENY: 2 };
+var Verdict = class _Verdict {
+  constructor(value) {
+    this.value = value;
+  }
+  static ALLOW = new _Verdict("ALLOW");
+  static REVIEW = new _Verdict("REVIEW");
+  static DENY = new _Verdict("DENY");
+  static of(value) {
+    return value === "DENY" ? _Verdict.DENY : value === "REVIEW" ? _Verdict.REVIEW : _Verdict.ALLOW;
+  }
+  /** The more severe of the two. */
+  atLeast(other) {
+    const o = typeof other === "string" ? _Verdict.of(other) : other;
+    return SEVERITY[o.value] > SEVERITY[this.value] ? o : this;
+  }
+  /** Whether a synchronous gate must stop the call (GAP-52). */
+  blocks(onReview) {
+    return this.value === "DENY" || this.value === "REVIEW" && onReview === "abort";
+  }
+  /** What the gate effectively did: DENY when it blocked, else the verdict itself. */
+  effective(onReview) {
+    return this.blocks(onReview) ? "DENY" : this.value;
+  }
+};
 
 export {
+  WIRE_SOURCES,
+  ALL_SOURCES,
+  EvidenceSourceSchema,
+  EvidenceSourceAllSchema,
+  SOURCE_ORDER,
+  compareBySourceSeq,
+  compareBySessionSource,
+  WIRE_KINDS,
+  PLATFORM_KINDS,
+  WireEvidenceKindSchema,
+  PlatformEvidenceKindSchema,
+  EvidenceKindSchema,
+  Hex64Schema,
+  SigSchema,
+  SessionIdSchema,
+  SeqSchema,
+  TimestampSchema,
+  JsonValueSchema,
+  EvidenceEventSchema,
+  isWireKind,
+  isPlatformKind,
+  INDICATOR_CODES,
+  ANNOTATION_CODES,
+  COLLECTOR_CODES,
+  DEFAULT_RULE_CODES,
+  REASON_CODE_PATTERN,
+  SelectorSyntaxError,
+  parseSelector,
+  formatSelector,
+  isSelectorRef,
+  parseSelectorRef,
+  walkPath,
+  SelectorStringSchema,
+  PRIMITIVES,
+  PrimitiveSchema,
+  RuleVerdictSchema,
+  RuleSchema,
+  PolicyRulesSchema,
+  AmountSchema,
+  DeclaredIntentSchema,
+  CreateSessionInputSchema,
+  CreateSessionOutputSchema,
+  MAX_BATCH_EVENTS,
+  EvidenceBatchInputSchema,
+  EventResultStatusSchema,
+  EventResultSchema,
+  ChainHeadSchema,
+  EvidenceAckSchema,
+  PaymentSummarySchema,
+  EvaluateInputSchema,
+  DecisionSchema,
+  EvaluateOutputSchema,
+  AnchorEntrySchema,
+  AnchorsOutputSchema,
+  CreatePolicyInputSchema,
+  CreatePolicyOutputSchema,
+  ApiErrorSchema,
+  SessionOpenPayloadSchema,
+  SESSION_CLOSE_REASONS,
+  SessionClosePayloadSchema,
+  IntentDeclaredPayloadSchema,
+  LlmCallStartPayloadSchema,
+  LlmCallEndPayloadSchema,
+  ToolCallStartPayloadSchema,
+  ToolCallEndPayloadSchema,
+  PAYMENT_ARTIFACTS,
+  PaymentMomentPayloadSchema,
+  GatewayDecisionPayloadSchema,
+  TransportGapPayloadSchema,
+  PlatformObservationPayloadSchema,
+  ANOMALY_TYPES,
+  PlatformAnomalyPayloadSchema,
+  payloadSchemaFor,
   Verdict
 };

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-YVMJ5CZX.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-GCKCAKHA.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 };