@belticlabs/agent-risk-sdk 0.1.0 → 0.2.0

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-GCKCAKHA.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.0";
+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,7 +1,8 @@
-import { PaymentSummary, PaymentMomentPayload } from './api.js';
-import { B as Beltic } from '../client-CVx9LgJC.js';
-import { S as Session } from '../session-BMNB1N1g.js';
-import './base58.js';
+import { a as PaymentSummary, P as PaymentMomentPayload } from '../index-Bjs3BPPU.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';
 
 interface CallToolParams {
     name: string;
@@ -12,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;
 /**

package/dist/mcp/index.js

@@ -1,6 +1,6 @@
 import {
   recordCall
-} from "../chunk-5TWO73OD.js";
+} from "../chunk-GSH5APZW.js";
 import {
   SESSION_EXTENSION
 } from "../chunk-VM7MK43J.js";
@@ -8,21 +8,22 @@ import {
   uuidv7
 } from "../chunk-SFGM7KOG.js";
 import {
-  x402Moments
-} from "../chunk-U5Z5Z2BQ.js";
+  Verdict
+} from "../chunk-46QN2KEZ.js";
 import {
   presentedFrom
 } from "../chunk-7G5EHNVW.js";
+import {
+  x402Moments
+} from "../chunk-LM4NIYE5.js";
 import {
   toJson,
   toJsonObject
 } from "../chunk-FQDHFTVR.js";
-import {
-  Verdict
-} from "../chunk-GCKCAKHA.js";
 
 // src/mcp/index.ts
 function wrapClient(session, client, opts = {}) {
+  if (!session) return client;
   const original = client.callTool.bind(client);
   const callTool = (params, ...rest) => recordCall(
     session,
@@ -85,8 +86,10 @@ function withBeltic(beltic, handler, opts) {
         presentedFrom(payment, { tool: opts.toolName, args: toJson(args) })
       );
       const out = await beltic.evaluate(session.id, payment);
-      verdict = Verdict.of(out.decision);
-      reasonCodes = out.reasonCodes;
+      if (out) {
+        verdict = out.verdict;
+        reasonCodes = out.reasonCodes;
+      }
     }
     await session.emit("gateway.decision", {
       gateway,

package/dist/middleware-BwAYpBTl.d.ts

@@ -0,0 +1,15 @@
+import { PaywallConfig } from '@x402/core/server';
+import { A as AttachOptions } from './adapter-CF-cUYSA.js';
+
+/**
+ * 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;
+};
+
+export type { GuardedMiddlewareOptions as G };

package/dist/protocol/index.d.ts

@@ -0,0 +1,158 @@
+import { b as JsonValue, E as EvidenceSourceAll } from '../index-Bjs3BPPU.js';
+export { A as ALL_SOURCES, c as ANOMALY_TYPES, d as Amount, e as AmountSchema, f as AnchorEntry, g as AnchorEntrySchema, h as AnchorsOutput, i as AnchorsOutputSchema, j as ApiError, k as ApiErrorSchema, C as ChainHead, l as ChainHeadSchema, m as CreatePolicyInput, n as CreatePolicyInputSchema, o as CreatePolicyOutput, p as CreatePolicyOutputSchema, q as CreateSessionInput, r as CreateSessionInputSchema, s as CreateSessionOutput, t as CreateSessionOutputSchema, D as Decision, u as DecisionSchema, v as DeclaredIntent, w as DeclaredIntentSchema, x as DigestedEnvelope, y as EvaluateInput, z as EvaluateInputSchema, B as EvaluateOutput, F as EvaluateOutputSchema, G as EventResult, H as EventResultSchema, I as EventResultStatus, K as EventResultStatusSchema, L as EvidenceAck, M as EvidenceAckSchema, N as EvidenceBatchInput, O as EvidenceBatchInputSchema, Q as EvidenceEnvelope, R as EvidenceEvent, S as EvidenceEventSchema, T as EvidenceKind, U as EvidenceKindSchema, V as EvidenceSource, W as EvidenceSourceAllSchema, X as EvidenceSourceSchema, Y as GatewayDecisionPayload, Z as GatewayDecisionPayloadSchema, _ as Hex64, $ as Hex64Schema, a0 as IntentDeclaredPayload, a1 as IntentDeclaredPayloadSchema, J as JsonObject, a2 as JsonValueSchema, a3 as LlmCallEndPayload, a4 as LlmCallEndPayloadSchema, a5 as LlmCallStartPayload, a6 as LlmCallStartPayloadSchema, a7 as MAX_BATCH_EVENTS, a8 as PAYMENT_ARTIFACTS, a9 as PLATFORM_KINDS, aa as PayloadByKind, P as PaymentMomentPayload, ab as PaymentMomentPayloadSchema, a as PaymentSummary, ac as PaymentSummarySchema, ad as PlatformAnomalyPayload, ae as PlatformAnomalyPayloadSchema, af as PlatformEvidenceKind, ag as PlatformEvidenceKindSchema, ah as PlatformObservationPayload, ai as PlatformObservationPayloadSchema, aj as SESSION_CLOSE_REASONS, ak as SOURCE_ORDER, al as SeqSchema, am as SessionClosePayload, an as SessionClosePayloadSchema, ao as SessionIdSchema, ap as SessionOpenPayload, aq as SessionOpenPayloadSchema, ar as Sig, as as SigSchema, at as TimestampSchema, au as ToolCallEndPayload, av as ToolCallEndPayloadSchema, aw as ToolCallStartPayload, ax as ToolCallStartPayloadSchema, ay as TransportGapPayload, az as TransportGapPayloadSchema, aA as WIRE_KINDS, aB as WIRE_SOURCES, aC as WireEvidenceKind, aD as WireEvidenceKindSchema, aE as compareBySessionSource, aF as compareBySourceSeq, aG as isPlatformKind, aH as isWireKind, aI as payloadSchemaFor } from '../index-Bjs3BPPU.js';
+import { z } from 'zod';
+export { O as OnReview, V as Verdict } from '../verdict-BAahb5po.js';
+
+declare const PRIMITIVES: readonly ["THRESHOLD", "MEMBERSHIP", "MATCH", "PRESENCE", "FRESHNESS"];
+declare const PrimitiveSchema: z.ZodEnum<{
+    THRESHOLD: "THRESHOLD";
+    MEMBERSHIP: "MEMBERSHIP";
+    MATCH: "MATCH";
+    PRESENCE: "PRESENCE";
+    FRESHNESS: "FRESHNESS";
+}>;
+type Primitive = z.infer<typeof PrimitiveSchema>;
+declare const RuleVerdictSchema: z.ZodEnum<{
+    DENY: "DENY";
+    REVIEW: "REVIEW";
+}>;
+type RuleVerdict = z.infer<typeof RuleVerdictSchema>;
+/**
+ * Params are JSON; a string value of the form `@<selector>` is resolved
+ * against the session view before the primitive runs (GAP-24).
+ */
+declare const RuleSchema: z.ZodObject<{
+    id: z.ZodString;
+    primitive: z.ZodEnum<{
+        THRESHOLD: "THRESHOLD";
+        MEMBERSHIP: "MEMBERSHIP";
+        MATCH: "MATCH";
+        PRESENCE: "PRESENCE";
+        FRESHNESS: "FRESHNESS";
+    }>;
+    selector: z.ZodString;
+    params: z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+    onFail: z.ZodEnum<{
+        DENY: "DENY";
+        REVIEW: "REVIEW";
+    }>;
+    onMissing: z.ZodOptional<z.ZodEnum<{
+        DENY: "DENY";
+        REVIEW: "REVIEW";
+        skip: "skip";
+    }>>;
+    code: z.ZodString;
+}, z.core.$strict>;
+type Rule = z.infer<typeof RuleSchema>;
+declare const PolicyRulesSchema: z.ZodObject<{
+    rules: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        primitive: z.ZodEnum<{
+            THRESHOLD: "THRESHOLD";
+            MEMBERSHIP: "MEMBERSHIP";
+            MATCH: "MATCH";
+            PRESENCE: "PRESENCE";
+            FRESHNESS: "FRESHNESS";
+        }>;
+        selector: z.ZodString;
+        params: z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+        onFail: z.ZodEnum<{
+            DENY: "DENY";
+            REVIEW: "REVIEW";
+        }>;
+        onMissing: z.ZodOptional<z.ZodEnum<{
+            DENY: "DENY";
+            REVIEW: "REVIEW";
+            skip: "skip";
+        }>>;
+        code: z.ZodString;
+    }, z.core.$strict>>;
+    scoreThresholds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+}, z.core.$strict>;
+type PolicyRules = z.infer<typeof PolicyRulesSchema>;
+
+/**
+ * Reason codes are the only thing that crosses the verdict boundary besides
+ * the verdict itself (Fraud Engine RFC › API: "the seller receives a verdict
+ * and reasons — never the record"). Three families, kept separate so the
+ * type system knows which layer may emit which.
+ */
+/** Static platform policy — may DENY alone (Fraud Engine RFC › Fraud indicators). */
+declare const INDICATOR_CODES: readonly ["CHAIN_BROKEN", "EVIDENCE_MISMATCH", "CREDENTIAL_REVOKED", "SESSION_INVALID", "PRINCIPAL_FLAGGED"];
+type IndicatorCode = (typeof INDICATOR_CODES)[number];
+/**
+ * Annotations describe the floor the decision was made on. They never change
+ * a verdict by themselves — `NO_AGENT_TRACE` is "thinner evidence", priced by
+ * the owner's rules, not a denial (GAP-43).
+ */
+declare const ANNOTATION_CODES: readonly ["NO_AGENT_TRACE", "NO_POLICY"];
+type AnnotationCode = (typeof ANNOTATION_CODES)[number];
+/** Why the Collector refused or downgraded an event (per-event ack, GAP-17). */
+declare const COLLECTOR_CODES: readonly ["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"];
+type CollectorCode = (typeof COLLECTOR_CODES)[number];
+/** Codes the platform default policy uses; owners may define their own (GAP-44). */
+declare const DEFAULT_RULE_CODES: readonly ["CAP_EXCEEDED", "PAYEE_NOT_ALLOWED", "NO_INTENT", "INTENT_EXPIRED"];
+type DefaultRuleCode = (typeof DEFAULT_RULE_CODES)[number];
+type ReasonCode = IndicatorCode | AnnotationCode | DefaultRuleCode | (string & {});
+declare const REASON_CODE_PATTERN: RegExp;
+
+/**
+ * Selector language (GAP-24; answers Fraud Engine RFC › Open Questions ›
+ * "Selector language"). One grammar addresses everything a rule or a
+ * detector may read from the session's materialized view:
+ *
+ *   selector := root path?
+ *   root     := 'payment' | 'intent' | 'session'
+ *             | 'signal[name=' NAME ']'
+ *             | 'evidence[kind=' KIND (',source=' SOURCE)? ']' ('[*]')?
+ *             | 'evidence[*]'
+ *   path     := ('.' IDENT | '[' INT ']')*
+ *
+ *   payment.*            the payment under evaluation (EvaluateInput)
+ *   intent.*             the session's declared intent
+ *   session.<field>      id · status · agentDid · hasAgentTrace · expiresAt · sourceBorn
+ *   signal[name=N]       latest value of signal N (a detector's namespace, dotted)
+ *   evidence[kind=K]     latest payload of kind K (any source unless source= given)
+ *   evidence[kind=K][*]  every payload of kind K, in (source, seq) order
+ *   evidence[*]          every envelope (chain checks)
+ *
+ * Inside rule params, a string `@<selector>` is a reference resolved the
+ * same way. The grammar is deliberately not JSONPath: it names four roots
+ * and nothing else, so a policy cannot address what the RFC says the
+ * engine must not expose.
+ */
+
+type PathSegment = {
+    key: string;
+} | {
+    index: number;
+};
+type Selector = {
+    root: 'payment' | 'intent' | 'session';
+    path: PathSegment[];
+} | {
+    root: 'signal';
+    name: string;
+    path: PathSegment[];
+} | {
+    root: 'evidence';
+    kind: string | '*';
+    source?: EvidenceSourceAll;
+    all: boolean;
+    path: PathSegment[];
+};
+declare class SelectorSyntaxError extends Error {
+    readonly input: string;
+    readonly at: number;
+    readonly code = "SELECTOR_SYNTAX";
+    constructor(input: string, at: number, detail: string);
+}
+declare function parseSelector(input: string): Selector;
+declare function formatSelector(sel: Selector): string;
+declare function isSelectorRef(value: unknown): value is `@${string}`;
+declare function parseSelectorRef(ref: string): Selector;
+/** Walk a `path` over a value; `undefined` when any step is missing. */
+declare function walkPath(value: unknown, path: readonly PathSegment[]): unknown;
+declare const SelectorStringSchema: z.ZodString;
+
+export { ANNOTATION_CODES, type AnnotationCode, COLLECTOR_CODES, type CollectorCode, DEFAULT_RULE_CODES, type DefaultRuleCode, EvidenceSourceAll, INDICATOR_CODES, type IndicatorCode, JsonValue, PRIMITIVES, type PathSegment, type PolicyRules, PolicyRulesSchema, type Primitive, PrimitiveSchema, REASON_CODE_PATTERN, type ReasonCode, type Rule, RuleSchema, type RuleVerdict, RuleVerdictSchema, type Selector, SelectorStringSchema, SelectorSyntaxError, formatSelector, isSelectorRef, parseSelector, parseSelectorRef, walkPath };

package/dist/protocol/index.js

@@ -0,0 +1,152 @@
+import {
+  ALL_SOURCES,
+  ANNOTATION_CODES,
+  ANOMALY_TYPES,
+  AmountSchema,
+  AnchorEntrySchema,
+  AnchorsOutputSchema,
+  ApiErrorSchema,
+  COLLECTOR_CODES,
+  ChainHeadSchema,
+  CreatePolicyInputSchema,
+  CreatePolicyOutputSchema,
+  CreateSessionInputSchema,
+  CreateSessionOutputSchema,
+  DEFAULT_RULE_CODES,
+  DecisionSchema,
+  DeclaredIntentSchema,
+  EvaluateInputSchema,
+  EvaluateOutputSchema,
+  EventResultSchema,
+  EventResultStatusSchema,
+  EvidenceAckSchema,
+  EvidenceBatchInputSchema,
+  EvidenceEventSchema,
+  EvidenceKindSchema,
+  EvidenceSourceAllSchema,
+  EvidenceSourceSchema,
+  GatewayDecisionPayloadSchema,
+  Hex64Schema,
+  INDICATOR_CODES,
+  IntentDeclaredPayloadSchema,
+  JsonValueSchema,
+  LlmCallEndPayloadSchema,
+  LlmCallStartPayloadSchema,
+  MAX_BATCH_EVENTS,
+  PAYMENT_ARTIFACTS,
+  PLATFORM_KINDS,
+  PRIMITIVES,
+  PaymentMomentPayloadSchema,
+  PaymentSummarySchema,
+  PlatformAnomalyPayloadSchema,
+  PlatformEvidenceKindSchema,
+  PlatformObservationPayloadSchema,
+  PolicyRulesSchema,
+  PrimitiveSchema,
+  REASON_CODE_PATTERN,
+  RuleSchema,
+  RuleVerdictSchema,
+  SESSION_CLOSE_REASONS,
+  SOURCE_ORDER,
+  SelectorStringSchema,
+  SelectorSyntaxError,
+  SeqSchema,
+  SessionClosePayloadSchema,
+  SessionIdSchema,
+  SessionOpenPayloadSchema,
+  SigSchema,
+  TimestampSchema,
+  ToolCallEndPayloadSchema,
+  ToolCallStartPayloadSchema,
+  TransportGapPayloadSchema,
+  Verdict,
+  WIRE_KINDS,
+  WIRE_SOURCES,
+  WireEvidenceKindSchema,
+  compareBySessionSource,
+  compareBySourceSeq,
+  formatSelector,
+  isPlatformKind,
+  isSelectorRef,
+  isWireKind,
+  parseSelector,
+  parseSelectorRef,
+  payloadSchemaFor,
+  walkPath
+} from "../chunk-46QN2KEZ.js";
+export {
+  ALL_SOURCES,
+  ANNOTATION_CODES,
+  ANOMALY_TYPES,
+  AmountSchema,
+  AnchorEntrySchema,
+  AnchorsOutputSchema,
+  ApiErrorSchema,
+  COLLECTOR_CODES,
+  ChainHeadSchema,
+  CreatePolicyInputSchema,
+  CreatePolicyOutputSchema,
+  CreateSessionInputSchema,
+  CreateSessionOutputSchema,
+  DEFAULT_RULE_CODES,
+  DecisionSchema,
+  DeclaredIntentSchema,
+  EvaluateInputSchema,
+  EvaluateOutputSchema,
+  EventResultSchema,
+  EventResultStatusSchema,
+  EvidenceAckSchema,
+  EvidenceBatchInputSchema,
+  EvidenceEventSchema,
+  EvidenceKindSchema,
+  EvidenceSourceAllSchema,
+  EvidenceSourceSchema,
+  GatewayDecisionPayloadSchema,
+  Hex64Schema,
+  INDICATOR_CODES,
+  IntentDeclaredPayloadSchema,
+  JsonValueSchema,
+  LlmCallEndPayloadSchema,
+  LlmCallStartPayloadSchema,
+  MAX_BATCH_EVENTS,
+  PAYMENT_ARTIFACTS,
+  PLATFORM_KINDS,
+  PRIMITIVES,
+  PaymentMomentPayloadSchema,
+  PaymentSummarySchema,
+  PlatformAnomalyPayloadSchema,
+  PlatformEvidenceKindSchema,
+  PlatformObservationPayloadSchema,
+  PolicyRulesSchema,
+  PrimitiveSchema,
+  REASON_CODE_PATTERN,
+  RuleSchema,
+  RuleVerdictSchema,
+  SESSION_CLOSE_REASONS,
+  SOURCE_ORDER,
+  SelectorStringSchema,
+  SelectorSyntaxError,
+  SeqSchema,
+  SessionClosePayloadSchema,
+  SessionIdSchema,
+  SessionOpenPayloadSchema,
+  SigSchema,
+  TimestampSchema,
+  ToolCallEndPayloadSchema,
+  ToolCallStartPayloadSchema,
+  TransportGapPayloadSchema,
+  Verdict,
+  WIRE_KINDS,
+  WIRE_SOURCES,
+  WireEvidenceKindSchema,
+  compareBySessionSource,
+  compareBySourceSeq,
+  formatSelector,
+  isPlatformKind,
+  isSelectorRef,
+  isWireKind,
+  parseSelector,
+  parseSelectorRef,
+  payloadSchemaFor,
+  walkPath
+};

package/dist/seller/anti-fraud-gateway.d.ts

@@ -1,7 +1,17 @@
-import { B as Beltic } from '../client-CVx9LgJC.js';
-import './api.js';
-import '../session-BMNB1N1g.js';
-import './base58.js';
+import { B as Beltic } from '../client-C-mV_3A0.js';
+import '../index-Bjs3BPPU.js';
+import 'zod';
+import '../verdict-BAahb5po.js';
+import '../session-5TClPLI4.js';
+
+/**
+ * Adapter for the anti-fraud port already in Beltic's `platform` monorepo
+ * (`x402-core/gateways/anti-fraud.gateway.interface.ts`), GAP-37. That
+ * port is binary and session-less; the mapping is lossy by construction:
+ * `REVIEW` becomes a deny unless `onReview` says otherwise, and reason
+ * codes travel joined in `reason`. The structural type is copied so this
+ * module needs no dependency on `platform`.
+ */
 
 interface PaymentRiskContext {
     wallet: string;