@belticlabs/agent-risk-sdk 0.2.0 → 0.4.0

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

@@ -1,91 +0,0 @@
-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/mcp/index.d.ts

@@ -1,60 +0,0 @@
-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;
-    arguments?: Record<string, unknown> | undefined;
-    _meta?: Record<string, unknown> | undefined;
-}
-/** Structural: `Client` from `@modelcontextprotocol/sdk/client` satisfies it. */
-interface McpClientLike {
-    callTool(params: CallToolParams, ...rest: unknown[]): Promise<unknown>;
-}
-declare function wrapClient<C extends McpClientLike>(session: Session | null | undefined, client: C, opts?: {
-    server?: string;
-}): C;
-/**
- * An in-band payment ask: any object in the result carrying an x402-style
- * `accepts` array (MRTR `input_required`, or a `_meta` envelope). One
- * moment, two artifacts — either becomes the same `payment.requested`.
- */
-declare function findPaymentAsk(result: unknown): PaymentMomentPayload | null;
-interface ServerCallExtra {
-    _meta?: Record<string, unknown> | undefined;
-    sessionId?: string | undefined;
-}
-interface WithBelticOptions<Args> {
-    toolName: string;
-    /** Return the payment this call moves, or null when the call is not value-moving. */
-    valueMoving?: (args: Args) => PaymentSummary | null;
-    gateway?: string;
-}
-type ToolHandler<Args, R> = (args: Args, extra: ServerCallExtra) => Promise<R> | R;
-interface McpErrorResult {
-    isError: true;
-    content: Array<{
-        type: 'text';
-        text: string;
-    }>;
-}
-/**
- * Wraps a tool handler on the seller side. Value-moving calls are evaluated
- * synchronously (DENY ⇒ isError result); every decided call is recorded
- * as `gateway.decision` in the buyer's session, or a seller-born one.
- */
-declare function withBeltic<Args, R>(beltic: Beltic, handler: ToolHandler<Args, R>, opts: WithBelticOptions<Args>): ToolHandler<Args, R | McpErrorResult>;
-/** Structural: `McpServer` from `@modelcontextprotocol/sdk/server/mcp` satisfies it. */
-interface McpServerLike {
-    registerTool(name: string, config: unknown, cb: (...a: never[]) => unknown): unknown;
-}
-interface WrapServerOptions {
-    valueMoving?: (toolName: string, args: unknown) => PaymentSummary | null;
-    gateway?: string;
-}
-/** Patches `registerTool` so every tool goes through `withBeltic`; `valueMoving` decides per tool. */
-declare function wrapServer<S extends McpServerLike>(beltic: Beltic, server: S, opts?: WrapServerOptions): S;
-
-export { type CallToolParams, type McpClientLike, type McpErrorResult, type McpServerLike, type ServerCallExtra, type ToolHandler, type WithBelticOptions, type WrapServerOptions, findPaymentAsk, withBeltic, wrapClient, wrapServer };

package/dist/mcp/index.js

@@ -1,130 +0,0 @@
-import {
-  recordCall
-} from "../chunk-GSH5APZW.js";
-import {
-  SESSION_EXTENSION
-} from "../chunk-VM7MK43J.js";
-import {
-  uuidv7
-} from "../chunk-SFGM7KOG.js";
-import {
-  Verdict
-} from "../chunk-46QN2KEZ.js";
-import {
-  presentedFrom
-} from "../chunk-7G5EHNVW.js";
-import {
-  x402Moments
-} from "../chunk-LM4NIYE5.js";
-import {
-  toJson,
-  toJsonObject
-} from "../chunk-FQDHFTVR.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,
-    "tool_call",
-    uuidv7(),
-    {
-      toolName: params.name,
-      input: toJson(params.arguments ?? {}),
-      transport: "mcp",
-      ...opts.server ? { server: opts.server } : {}
-    },
-    async () => {
-      await session.flush();
-      return original(
-        { ...params, _meta: { ...params._meta ?? {}, [SESSION_EXTENSION]: session.id } },
-        ...rest
-      );
-    },
-    async (result) => {
-      const ask = findPaymentAsk(result);
-      if (ask) await session.emit("payment.requested", ask);
-      return { output: toJson(result) };
-    }
-  );
-  return new Proxy(client, {
-    get(target, prop, receiver) {
-      return prop === "callTool" ? callTool : Reflect.get(target, prop, receiver);
-    }
-  });
-}
-function findPaymentAsk(result) {
-  const seen = /* @__PURE__ */ new Set();
-  const walk = (v, depth) => {
-    if (!v || typeof v !== "object" || seen.has(v) || depth > 6) return null;
-    seen.add(v);
-    const o = v;
-    const first = Array.isArray(o.accepts) ? o.accepts[0] : void 0;
-    if (typeof first?.payTo === "string") {
-      return x402Moments.ask(first, toJsonObject(o));
-    }
-    for (const child of Array.isArray(o) ? o : Object.values(o)) {
-      const hit = walk(child, depth + 1);
-      if (hit) return hit;
-    }
-    return null;
-  };
-  return walk(result, 0);
-}
-function withBeltic(beltic, handler, opts) {
-  const gateway = opts.gateway ?? "sdk-mcp";
-  return async (args, extra) => {
-    const bound = extra?._meta?.[SESSION_EXTENSION];
-    const session = await beltic.sessions.ensure(typeof bound === "string" ? bound : null);
-    const payment = opts.valueMoving?.(args) ?? null;
-    let verdict = Verdict.ALLOW;
-    let reasonCodes = [];
-    if (payment) {
-      await session.emit(
-        "payment.presented",
-        presentedFrom(payment, { tool: opts.toolName, args: toJson(args) })
-      );
-      const out = await beltic.evaluate(session.id, payment);
-      if (out) {
-        verdict = out.verdict;
-        reasonCodes = out.reasonCodes;
-      }
-    }
-    await session.emit("gateway.decision", {
-      gateway,
-      call: { tool: opts.toolName, args: toJson(args) },
-      decision: verdict.effective(beltic.onReview),
-      reasonCodes,
-      record: { valueMoving: payment !== null, bound: typeof bound === "string" }
-    });
-    if (verdict.blocks(beltic.onReview)) {
-      return {
-        isError: true,
-        content: [
-          { type: "text", text: `Beltic ${verdict.value}: ${reasonCodes.join(",") || "denied"}` }
-        ]
-      };
-    }
-    return handler(args, extra);
-  };
-}
-function wrapServer(beltic, server, opts = {}) {
-  const original = server.registerTool.bind(server);
-  server.registerTool = ((name, config, cb) => original(
-    name,
-    config,
-    withBeltic(beltic, cb, {
-      toolName: name,
-      ...opts.gateway ? { gateway: opts.gateway } : {},
-      valueMoving: (args) => opts.valueMoving?.(name, args) ?? null
-    })
-  ));
-  return server;
-}
-export {
-  findPaymentAsk,
-  withBeltic,
-  wrapClient,
-  wrapServer
-};

package/dist/middleware-BwAYpBTl.d.ts

@@ -1,15 +0,0 @@
-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/seller/anti-fraud-gateway.d.ts

@@ -1,42 +0,0 @@
-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;
-    resource: string;
-    amountAtomic: string;
-    asset: string;
-    network: string;
-    paymentIdentifier?: string;
-    /** Not in the platform port yet — pass it when you have it. */
-    sessionId?: string;
-    payTo?: string;
-}
-type RiskDecision = {
-    allow: true;
-} | {
-    allow: false;
-    reason: string;
-};
-interface AntiFraudGateway {
-    assess(context: PaymentRiskContext): Promise<RiskDecision>;
-}
-declare class BelticAntiFraudGateway implements AntiFraudGateway {
-    private readonly beltic;
-    constructor(beltic: Beltic);
-    assess(ctx: PaymentRiskContext): Promise<RiskDecision>;
-}
-
-export { type AntiFraudGateway, BelticAntiFraudGateway, type PaymentRiskContext, type RiskDecision };

package/dist/seller/anti-fraud-gateway.js

@@ -1,38 +0,0 @@
-import {
-  presentedFrom
-} from "../chunk-7G5EHNVW.js";
-import {
-  x402Summary
-} from "../chunk-LM4NIYE5.js";
-import "../chunk-FQDHFTVR.js";
-
-// src/seller/anti-fraud-gateway.ts
-var BelticAntiFraudGateway = class {
-  constructor(beltic) {
-    this.beltic = beltic;
-  }
-  async assess(ctx) {
-    const session = await this.beltic.sessions.ensure(ctx.sessionId ?? null);
-    const payment = x402Summary(
-      {
-        payTo: ctx.payTo ?? ctx.resource,
-        amount: ctx.amountAtomic,
-        network: ctx.network,
-        asset: ctx.asset
-      },
-      { payer: ctx.wallet }
-    );
-    await session.emit(
-      "payment.presented",
-      presentedFrom(payment, {
-        resource: ctx.resource,
-        ...ctx.paymentIdentifier ? { paymentIdentifier: ctx.paymentIdentifier } : {}
-      })
-    );
-    const out = await this.beltic.evaluate(session.id, payment);
-    return out?.verdict.blocks(this.beltic.onReview) ? { allow: false, reason: `${out.decision}:${out.reasonCodes.join(",")}` } : { allow: true };
-  }
-};
-export {
-  BelticAntiFraudGateway
-};

package/dist/session-5TClPLI4.d.ts

@@ -1,250 +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, aw as ToolCallStartPayload, b as JsonValue, 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).
- *
- * Evidence is a side channel of the agent's work: with `failOpen` an emit
- * that cannot be chained (halted chain, closed transport) is reported and
- * returns `false` instead of throwing into the model or tool call it
- * observes (GAP-70).
- */
-
-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;
-    /** Report instead of throw when an event cannot be chained (GAP-70). */
-    failOpen?: boolean | undefined;
-    onError?: ((err: Error) => void) | undefined;
-}
-/**
- * One tool call as a span: `tool_call.start` now, `tool_call.end` with the
- * outcome and the elapsed time when the host reports it. For hosts that run
- * their own tool loop and cannot hand the SDK an `execute` to wrap.
- */
-interface ToolCallSpan {
-    readonly callId: string;
-    end(outcome?: {
-        output?: JsonValue;
-    }): Promise<boolean>;
-    fail(error: unknown, outcome?: {
-        output?: JsonValue;
-    }): Promise<boolean>;
-}
-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. `false` when the event was dropped, or (fail-open) when
-     * the chain can no longer take it.
-     */
-    emit<K extends WireEvidenceKind>(kind: K, payload: PayloadByKind[K]): Promise<boolean>;
-    /** The tool call whose `execute` the host runs itself; see `ToolCallSpan`. */
-    toolCall(call: ToolCallStartPayload): ToolCallSpan;
-    private chainEvent;
-    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;
-}
-/** What `open` sends when it actually opens: a value, or a resolver run only then. */
-type OpenSessionInput = StartSessionInput | (() => StartSessionInput | Promise<StartSessionInput>);
-interface SessionsDeps {
-    api: ApiClient;
-    transport: Transport;
-    identity?: AgentIdentity | undefined;
-    redact?: RedactFn | undefined;
-    now?: (() => Date) | undefined;
-    sdkVersion: string;
-    failOpen?: boolean | undefined;
-    onError?: ((err: Error) => void) | undefined;
-    /** Fail-open only: after the platform refused to open a session, `open` resolves null for this long (GAP-71). */
-    openRetryMs?: number | undefined;
-}
-declare const DEFAULT_OPEN_RETRY_MS = 60000;
-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;
-    /** Buyer sessions by the host's own key (GAP-71). */
-    private readonly opened;
-    private retryAt;
-    constructor(deps: SessionsDeps);
-    /**
-     * 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: string, input?: OpenSessionInput): Promise<Session | null>;
-    private forget;
-    private openFresh;
-    /** Buyer half: create an AGENT_TRACE session bound to the agent identity, then announce it on the chain. */
-    start(input?: StartSessionInput): Promise<Session>;
-    private identityFor;
-    private create;
-    /** 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_OPEN_RETRY_MS as D, type OpenSessionInput as O, type RedactFn as R, Session as S, type ToolCallSpan as T, ApiClient as a, type ApiClientOptions as b, DEFAULT_TRANSPORT as c, type SessionBorn as d, Sessions as e, type StartSessionInput as f, Transport as g, TransportClosedError as h, type TransportOptions as i, ephemeralIdentity as j, fileIdentity as k, identityFromSeed as l };

package/dist/verdict-BAahb5po.d.ts

@@ -1,26 +0,0 @@
-import { D as Decision } from './index-Bjs3BPPU.js';
-
-/**
- * The verdict as a value (Fraud Engine RFC › API: ALLOW | DENY | REVIEW).
- * Layers combine by severity (GAP-45); a synchronous seller hook turns
- * REVIEW into a stop or a pass according to its `onReview` (GAP-52). Both
- * halves of the SDK and the engine share this one rule.
- */
-
-type OnReview = 'abort' | 'allow';
-declare class Verdict {
-    readonly value: Decision;
-    private constructor();
-    static readonly ALLOW: Verdict;
-    static readonly REVIEW: Verdict;
-    static readonly DENY: Verdict;
-    static of(value: Decision): Verdict;
-    /** The more severe of the two. */
-    atLeast(other: Verdict | Decision): Verdict;
-    /** Whether a synchronous gate must stop the call (GAP-52). */
-    blocks(onReview: OnReview): boolean;
-    /** What the gate effectively did: DENY when it blocked, else the verdict itself. */
-    effective(onReview: OnReview): Decision;
-}
-
-export { type OnReview as O, Verdict as V };

package/dist/x402/express.d.ts

@@ -1,15 +0,0 @@
-import { RoutesConfig, x402ResourceServer } from '@x402/core/server';
-import { RequestHandler } from 'express';
-import { B as Beltic } from '../client-C-mV_3A0.js';
-import { G as GuardedMiddlewareOptions } from '../middleware-BwAYpBTl.js';
-export { a as attachX402 } from '../adapter-CF-cUYSA.js';
-import '../index-Bjs3BPPU.js';
-import 'zod';
-import '../verdict-BAahb5po.js';
-import '../session-5TClPLI4.js';
-
-/** Seller half for express: `@x402/express`'s payment middleware with the Beltic hooks attached. */
-
-declare function belticPaymentMiddleware(beltic: Beltic, routes: RoutesConfig, server: x402ResourceServer, opts?: GuardedMiddlewareOptions): RequestHandler;
-
-export { belticPaymentMiddleware };