@belticlabs/agent-risk-sdk 0.1.1 → 0.3.0

package/dist/x402/index.d.ts

@@ -1,55 +1,116 @@
-export { A as AttachOptions, b as AttachedX402, C as CorrelationContext, G as GuardedMiddlewareOptions, a as attachX402, g as guardedPaymentMiddleware } from '../middleware-D-ejQIoE.js';
-import { S as Session } from '../session-B2mfurae.js';
-import { P as PaymentMomentPayload, J as JsonObject } from '../index-Bjs3BPPU.js';
-import { PaymentPayload, PaymentRequired, PaymentRequirements } from '@x402/core/types';
+export { A as AttachOptions, b as AttachedX402, C as CorrelationContext, a as attachX402 } from '../adapter-BEpzr2R3.js';
+import { S as SessionSource } from '../session-DsBWEP8d.js';
+import { v as DeclaredIntent, P as PaymentMomentPayload, J as JsonObject, a as PaymentSummary } from '../verdict-6vCyoAHE.js';
 import '@x402/core/server';
-import '../client-NxpD_384.js';
-import '../verdict-BAahb5po.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 const DECISION_HEADER = "Beltic-Decision-Id";
 declare function sessionIdOf(extensions: Readonly<Record<string, unknown>> | undefined): string | null;
+declare function decisionIdOf(extensions: Readonly<Record<string, unknown>> | undefined): string | null;
 
-declare function belticFetch(session: Session, inner?: typeof globalThis.fetch): typeof globalThis.fetch;
+/**
+ * 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.
+ */
+declare function belticFetch(source: SessionSource, inner?: typeof globalThis.fetch): typeof globalThis.fetch;
+
+/**
+ * The declared intent for an x402 mandate (Fraud SDK RFC › Session ›
+ * `intent.declared`). The cap must be in the currency the rail's moments
+ * carry — `<network>/<asset>`, atomic units (GAP-49) — or the platform's
+ * spend detectors compare two currencies and never meet; this is the one
+ * place a buyer spells that. Everything else is the protocol's own shape.
+ */
+
+interface X402IntentInput {
+    mandate: string;
+    network: string;
+    asset: string;
+    /** Atomic units of `asset`, as x402 carries amounts — a decimal string or a bigint, never a float. */
+    maxAmount: string | bigint;
+    validUntil: string | Date;
+    merchantAllowlist?: string[] | undefined;
+}
+declare function x402Intent(input: X402IntentInput): DeclaredIntent;
 
 /**
  * x402 artifacts → protocol moments (Fraud SDK RFC › Protocol Adapter —
  * x402). The moment is normalized (payee, amount, payer) so both sides of
  * a purchase compare; the artifact travels whole in `raw`. For x402 the
  * currency is `<network>/<asset>` (GAP-49) and the value is the atomic
- * amount as the protocol carries it.
+ * amount as the protocol carries it — `x402Summary` gives a buyer the same
+ * normalization for the payment it is about to evaluate, so what it asks
+ * about and what the wrapper records are one and the same.
  */
 
-type Readonlyish<T> = {
-    readonly [K in keyof T]: Readonlyish<T[K]>;
-} | T;
 declare function x402Currency(network: string, asset: string): string;
-/** The minimum an `accepts` entry needs to become a moment; unknown parts are named, never dropped. */
+/**
+ * The minimum an `accepts` entry needs to become a moment; unknown parts
+ * are named, never dropped. v1 spells the amount `maxAmountRequired`.
+ */
 interface AcceptsLike {
     payTo?: string | undefined;
     amount?: string | undefined;
+    maxAmountRequired?: string | undefined;
     network?: string | undefined;
     asset?: string | undefined;
 }
+/**
+ * A 402 challenge and a presented payment of either generation, 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;
+    /** v1 names the network here, beside the payload, and nowhere else. */
+    network?: string | 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
+ * moment below is this plus its artifact and `raw`.
+ */
+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: Readonlyish<PaymentPayload>): string | undefined;
+declare function payerOf(payload: PaymentPayloadLike): string | undefined;
 declare const x402Moments: {
-    /** The 402 challenge as the buyer saw it. */
-    required(required: Readonlyish<PaymentRequired>): PaymentMomentPayload;
+    /** The 402 challenge as the buyer saw it, v2 header or v1 body. */
+    required(required: PaymentRequiredLike): PaymentMomentPayload;
     /** The requirements the seller's resource server resolved for a request. */
-    requirements(req: Readonlyish<PaymentRequirements>): PaymentMomentPayload;
+    requirements(req: AcceptsLike): PaymentMomentPayload;
     /** A route's static `accepts` config, before any payment header exists. */
     route(route: unknown, raw: JsonObject): PaymentMomentPayload;
     /** An in-band ask (MRTR `input_required` or a `_meta` envelope) carrying an x402-style `accepts`. */
     ask(first: AcceptsLike, raw: JsonObject): PaymentMomentPayload;
-    /** The signed payment the buyer presented. */
-    payload(payload: Readonlyish<PaymentPayload>): PaymentMomentPayload;
+    /**
+     * 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: PaymentPayloadLike, accepts?: AcceptsLike | undefined): PaymentMomentPayload;
 };
 
-export { type AcceptsLike, SESSION_EXTENSION, SESSION_HEADER, belticFetch, payerOf, sessionIdOf, x402Currency, x402Moments };
+export { type AcceptsLike, DECISION_EXTENSION, DECISION_HEADER, type PaymentPayloadLike, type PaymentRequiredLike, SESSION_EXTENSION, SESSION_HEADER, type X402IntentInput, belticFetch, decisionIdOf, payerOf, sessionIdOf, x402Currency, x402Intent, x402Moments, x402Summary };

package/dist/x402/index.js

@@ -1,67 +1,141 @@
 import {
-  attachX402,
-  guardedPaymentMiddleware
-} from "../chunk-W2OY7QXV.js";
+  attachX402
+} from "../chunk-OKC6VMFH.js";
+import {
+  Session,
+  Sessions
+} from "../chunk-4MG6VNAU.js";
 import {
+  DECISION_EXTENSION,
+  DECISION_HEADER,
   SESSION_EXTENSION,
   SESSION_HEADER,
+  decisionIdOf,
   sessionIdOf
-} from "../chunk-VM7MK43J.js";
-import "../chunk-SFGM7KOG.js";
+} from "../chunk-FAQ442YH.js";
+import "../chunk-X3W2Z5GC.js";
+import "../chunk-46QN2KEZ.js";
 import {
   payerOf,
   x402Currency,
-  x402Moments
-} from "../chunk-U5Z5Z2BQ.js";
-import "../chunk-7G5EHNVW.js";
+  x402Moments,
+  x402Summary
+} from "../chunk-LM4NIYE5.js";
 import "../chunk-FQDHFTVR.js";
-import "../chunk-46QN2KEZ.js";
 
 // src/x402/fetch.ts
-import {
-  decodePaymentRequiredHeader,
-  decodePaymentSignatureHeader,
-  encodePaymentSignatureHeader
-} from "@x402/core/http";
-function belticFetch(session, inner = globalThis.fetch) {
+var BASE64 = /^[A-Za-z0-9+/]*={0,2}$/;
+var CHALLENGE_MEMORY = 32;
+function belticFetch(source, inner = globalThis.fetch) {
+  if (!source) return inner;
+  const run = source instanceof Session ? null : source;
+  const challenges = /* @__PURE__ */ new Map();
   return async (input, init) => {
+    const session = await Sessions.resolve(source);
+    if (!session) return inner(input, init);
+    const url = urlOf(input);
     const headers = new Headers(
       init?.headers ?? (input instanceof Request ? input.headers : void 0)
     );
     headers.set(SESSION_HEADER, session.id);
-    const sigHeader = headers.get("PAYMENT-SIGNATURE");
-    if (sigHeader) {
-      try {
-        const payload = decodePaymentSignatureHeader(sigHeader);
-        payload.extensions = { ...payload.extensions ?? {}, [SESSION_EXTENSION]: session.id };
-        headers.set("PAYMENT-SIGNATURE", encodePaymentSignatureHeader(payload));
-        await session.emit("payment.presented", x402Moments.payload(payload));
-        await session.flush();
-      } catch {
-      }
+    const signature = headers.get("PAYMENT-SIGNATURE");
+    const presented = signature ?? headers.get("X-PAYMENT");
+    const payload = presented ? decodeHeader(presented) : null;
+    if (payload) {
+      const accepts = payload.accepted ?? answeredAccepts(challenges.get(url), payload);
+      const decision = run?.decisionFor(x402Moments.payload(payload, accepts));
+      const decisionId = decision && !decision.absent ? decision.decisionId : null;
+      const bound = signature ? {
+        ...payload,
+        extensions: {
+          ...payload.extensions,
+          [SESSION_EXTENSION]: session.id,
+          ...decisionId ? { [DECISION_EXTENSION]: decisionId } : {}
+        }
+      } : payload;
+      if (signature) headers.set("PAYMENT-SIGNATURE", encodeHeader(bound));
+      else if (decisionId) headers.set(DECISION_HEADER, decisionId);
+      await session.emit("payment.presented", x402Moments.payload(bound, accepts));
+      await session.flush();
     }
     const res = await inner(input, { ...init, headers });
-    const required = res.status === 402 ? res.headers.get("PAYMENT-REQUIRED") : null;
+    if (res.status !== 402) return res;
+    const required = await challengeOf(res);
     if (required) {
-      try {
-        await session.emit(
-          "payment.requested",
-          x402Moments.required(decodePaymentRequiredHeader(required))
-        );
-      } catch {
-      }
+      challenges.set(url, required);
+      if (challenges.size > CHALLENGE_MEMORY) challenges.delete(challenges.keys().next().value);
+      await session.emit("payment.requested", x402Moments.required(required));
     }
     return res;
   };
 }
+function decodeHeader(value) {
+  if (!BASE64.test(value)) return null;
+  try {
+    const parsed = JSON.parse(Buffer.from(value, "base64").toString("utf8"));
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function encodeHeader(value) {
+  return Buffer.from(JSON.stringify(value), "utf8").toString("base64");
+}
+function urlOf(input) {
+  return typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+}
+async function challengeOf(res) {
+  const header = res.headers.get("PAYMENT-REQUIRED");
+  if (header) return decodeHeader(header);
+  if (!/json/i.test(res.headers.get("content-type") ?? "")) return null;
+  try {
+    const body = await res.clone().json();
+    return Array.isArray(body?.accepts) ? body : null;
+  } catch {
+    return null;
+  }
+}
+function answeredAccepts(required, payload) {
+  const auth = payload.payload?.authorization;
+  const payTo = typeof auth?.to === "string" ? auth.to : void 0;
+  const amount = typeof auth?.value === "string" ? auth.value : void 0;
+  const options = required?.accepts ?? [];
+  const answered = options.find(
+    (a) => a.payTo?.toLowerCase() === payTo?.toLowerCase() && (a.amount ?? a.maxAmountRequired) === amount
+  ) ?? options[0];
+  if (answered) return answered;
+  if (!payTo && !amount) return void 0;
+  return {
+    ...payTo ? { payTo } : {},
+    ...amount ? { amount } : {},
+    ...payload.network ? { network: payload.network } : {}
+  };
+}
+
+// src/x402/intent.ts
+function x402Intent(input) {
+  return {
+    mandate: input.mandate,
+    maxAmount: {
+      value: input.maxAmount.toString(),
+      currency: x402Currency(input.network, input.asset)
+    },
+    validUntil: new Date(input.validUntil).toISOString(),
+    ...input.merchantAllowlist ? { merchantAllowlist: input.merchantAllowlist } : {}
+  };
+}
 export {
+  DECISION_EXTENSION,
+  DECISION_HEADER,
   SESSION_EXTENSION,
   SESSION_HEADER,
   attachX402,
   belticFetch,
-  guardedPaymentMiddleware,
+  decisionIdOf,
   payerOf,
   sessionIdOf,
   x402Currency,
-  x402Moments
+  x402Intent,
+  x402Moments,
+  x402Summary
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@belticlabs/agent-risk-sdk",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "The Beltic Agent Risk SDK — one client, two halves: instrument the buyer agent (AI SDK, x402 fetch, MCP client) and guard the seller boundary (x402, MCP server, evaluate).",
   "license": "UNLICENSED",
   "repository": {

package/dist/chunk-5TWO73OD.js

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

package/dist/chunk-VM7MK43J.js

@@ -1,13 +0,0 @@
-// src/x402/binding.ts
-var SESSION_EXTENSION = "beltic.sessionId";
-var SESSION_HEADER = "Beltic-Session-Id";
-function sessionIdOf(extensions) {
-  const v = extensions?.[SESSION_EXTENSION];
-  return typeof v === "string" && v.length > 0 ? v : null;
-}
-
-export {
-  SESSION_EXTENSION,
-  SESSION_HEADER,
-  sessionIdOf
-};

package/dist/client-NxpD_384.d.ts

@@ -1,64 +0,0 @@
-import { a as PaymentSummary, B as EvaluateOutput } from './index-Bjs3BPPU.js';
-import { O as OnReview } from './verdict-BAahb5po.js';
-import { a as ApiClient, T as Transport, d as Sessions, A as AgentIdentity, b as ApiClientOptions, g as TransportOptions, R as RedactFn } from './session-B2mfurae.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 the seller
- * half. 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), 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.
- */
-
-declare const SDK_VERSION = "0.1.1";
-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;
-}
-declare class Beltic {
-    readonly api: ApiClient;
-    readonly transport: Transport;
-    readonly sessions: Sessions;
-    readonly identity: AgentIdentity | undefined;
-    readonly correlation: CorrelationStore;
-    readonly onReview: OnReview;
-    constructor(opts: BelticOptions);
-    /** Read-your-writes: the platform must hold the evidence before it judges it (GAP-16). */
-    evaluate(sessionId: string, payment: PaymentSummary): Promise<EvaluateOutput>;
-    flush(): Promise<void>;
-    shutdown(): Promise<void>;
-}
-declare function createBeltic(opts: BelticOptions): Beltic;
-
-export { Beltic as B, type CorrelationStore as C, MemoryCorrelationStore as M, SDK_VERSION as S, type BelticOptions as a, createBeltic as c };

package/dist/middleware-D-ejQIoE.d.ts

@@ -1,40 +0,0 @@
-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';
-
-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;
-
-/**
- * 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 };

package/dist/session-B2mfurae.d.ts

@@ -1,196 +0,0 @@
-import { L as EvidenceAck, G as EventResult, R as EvidenceEvent, V as EvidenceSource, aC as WireEvidenceKind, J as JsonObject, C as ChainHead, aa as PayloadByKind, am as SessionClosePayload, v as DeclaredIntent } from './index-Bjs3BPPU.js';
-
-/**
- * The edge signs event digests (Fraud SDK RFC › Modules › Identity Module);
- * the platform signs its own PLATFORM chain and epoch anchors. 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>;
-}
-
-interface ApiClientOptions {
-    baseUrl: string;
-    apiKey: string;
-    fetch?: typeof globalThis.fetch;
-    timeoutMs?: number;
-    userAgent?: 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 and network failures are retried by the transport; 4xx are not. */
-    get retryable(): boolean;
-}
-declare class ApiClient {
-    private readonly baseUrl;
-    private readonly fetchImpl;
-    private readonly timeoutMs;
-    private readonly headers;
-    constructor(opts: ApiClientOptions);
-    post<T>(path: string, body: unknown, headers?: Record<string, string>): Promise<T>;
-    get<T>(path: string, query?: Record<string, string | undefined>): Promise<T>;
-    private request;
-}
-
-interface AgentIdentity {
-    did: string;
-    signer: Signer;
-    /** Opaque credential presented at session start (stored, not verified this phase). */
-    credential?: string;
-}
-declare function identityFromSeed(seed: Uint8Array, credential?: string): AgentIdentity;
-declare function ephemeralIdentity(credential?: string): AgentIdentity;
-/** A JSON keystore on disk: `{ "seed": "<64 hex>" }`, created 0600 when missing. */
-declare function fileIdentity(path: string, credential?: string): AgentIdentity;
-
-/**
- * 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 on network / 5xx; a `fork` or `rejected` ack halts
- * the chain and surfaces `ChainRejectedError` — an SDK must not silently
- * keep chaining onto a head the platform never accepted.
- */
-
-interface TransportOptions {
-    maxBatch: number;
-    flushMs: number;
-    /** Total buffered events across chains; beyond this new events are dropped (GAP-38). */
-    maxBuffered: number;
-    backoff: {
-        baseMs: number;
-        maxMs: number;
-        maxAttempts: number;
-    };
-    onAck?: (ack: EvidenceAck) => void;
-    onError?: (err: Error) => void;
-    onChainHalted?: (err: ChainRejectedError) => void;
-    setTimeout?: typeof globalThis.setTimeout;
-    clearTimeout?: typeof globalThis.clearTimeout;
-}
-declare const DEFAULT_TRANSPORT: TransportOptions;
-declare class ChainRejectedError extends Error {
-    readonly sessionId: string;
-    readonly source: string;
-    readonly result: EventResult;
-    constructor(sessionId: string, source: string, result: EventResult);
-}
-declare class TransportClosedError extends Error {
-    constructor();
-}
-declare class Transport {
-    private readonly api;
-    private readonly opts;
-    private readonly chains;
-    private buffered;
-    private timer;
-    private closed;
-    private inFlightCount;
-    private drainWaiters;
-    constructor(api: ApiClient, opts?: Partial<TransportOptions>);
-    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;
-    /** Send everything pending and wait for every in-flight batch to settle (ack or halt). */
-    flush(): Promise<void>;
-    close(): Promise<void>;
-    private schedule;
-    private unschedule;
-    private drained;
-    private settleWaiters;
-    private flushChain;
-    private send;
-}
-
-/**
- * A risk session as the SDK sees it: one chain per (sessionId, source),
- * built at the edge (Fraud SDK RFC › Wire contract). The buyer half opens
- * AGENT_TRACE sessions and announces them with `session.open` (seq 0) and
- * `intent.declared` (seq 1; GAP-23/60); the seller half attaches to a bound
- * session or opens its own INTERNAL_NETWORK session (GAP-13).
- *
- * `seq` is handed out only when the transport has room for the event
- * (GAP-38): a dropped event never leaves a hole — the next accepted event
- * is preceded by a `transport.gap` that counts the drops. `redact` is off
- * by default (GAP-33).
- */
-
-type RedactFn = (kind: WireEvidenceKind, payload: JsonObject) => JsonObject;
-/** Who created the session — the seller half treats a bound session as buyer-born. */
-type SessionBorn = 'buyer' | 'seller';
-interface SessionDeps {
-    transport: Transport;
-    signer?: Signer | undefined;
-    redact?: RedactFn | undefined;
-    now?: (() => Date) | undefined;
-    /** Called once the session closed, so the registry can forget it. */
-    onClosed?: ((session: Session) => void) | undefined;
-}
-declare class Session {
-    private readonly deps;
-    readonly id: string;
-    readonly source: EvidenceSource;
-    readonly expiresAt: string | null;
-    readonly born: SessionBorn;
-    private chain;
-    private building;
-    private dropped;
-    private droppedFirstTs;
-    private droppedLastTs;
-    private closed;
-    private readonly now;
-    constructor(deps: SessionDeps, id: string, source: EvidenceSource, expiresAt: string | null, born: SessionBorn);
-    get head(): ChainHead | null;
-    get droppedCount(): number;
-    /** Resolves once the event is sequenced and buffered — not once it is acknowledged. */
-    emit<K extends WireEvidenceKind>(kind: K, payload: PayloadByKind[K]): Promise<boolean>;
-    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;
-}
-interface StartSessionInput {
-    intent?: DeclaredIntent;
-    runtime?: {
-        framework?: string;
-        model?: string;
-    };
-    attestations?: JsonObject;
-}
-interface SessionsDeps {
-    api: ApiClient;
-    transport: Transport;
-    identity?: AgentIdentity | undefined;
-    redact?: RedactFn | undefined;
-    now?: (() => Date) | undefined;
-    sdkVersion: string;
-}
-declare class Sessions {
-    private readonly deps;
-    /**
-     * One session 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 sessions are forgotten; a process restart
-     * mid-session still loses the head (GAP-67).
-     */
-    private readonly attached;
-    constructor(deps: SessionsDeps);
-    /** Buyer half: create an AGENT_TRACE session bound to the agent identity, then announce it on the chain. */
-    start(input?: StartSessionInput): Promise<Session>;
-    /** Seller half: emit INTERNAL_NETWORK evidence into a session the buyer bound, or open a seller-born one. */
-    ensure(sessionId?: string | null): Promise<Session>;
-    private attach;
-}
-
-export { type AgentIdentity as A, BelticApiError as B, ChainRejectedError as C, DEFAULT_TRANSPORT as D, type RedactFn as R, Session as S, Transport as T, ApiClient as a, type ApiClientOptions as b, type SessionBorn as c, Sessions as d, type StartSessionInput as e, TransportClosedError as f, type TransportOptions as g, ephemeralIdentity as h, fileIdentity as i, identityFromSeed as j };