@belticlabs/agent-risk-sdk 0.4.0 → 0.6.0

package/dist/adapter-AjCgj-KM.d.ts

@@ -0,0 +1,6 @@
+import { x402ResourceServer, x402HTTPResourceServer } from '@x402/core/server';
+import { B as Beltic } from './client-CgCjOrRP.js';
+
+declare function attachX402(beltic: Beltic, server: x402ResourceServer, http?: x402HTTPResourceServer): void;
+
+export { attachX402 as a };

package/dist/ai/index.d.ts

@@ -1,19 +1,9 @@
-import { P as PaymentMomentPayload } from '../verdict-CDAsxktI.js';
-import { LanguageModelMiddleware, Tool, ToolSet } from 'ai';
-import { S as SessionSource } from '../session-gK51QVAM.js';
+import { LanguageModelMiddleware, ToolSet } from 'ai';
+import { S as Session } from '../session-Dcof4UIn.js';
+import '../index-IfY4XCvJ.js';
 import 'zod';
 
-interface PaymentMoments {
-    requested?: PaymentMomentPayload;
-    presented?: PaymentMomentPayload;
-}
-interface WrapToolOptions<I = unknown, O = unknown> {
-    name?: string;
-    /** 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(source: SessionSource): LanguageModelMiddleware;
-declare function wrapTool<T extends Tool>(source: SessionSource, tool: T, opts?: WrapToolOptions): T;
-declare function wrapTools<T extends ToolSet>(source: SessionSource, tools: T, opts?: Record<string, WrapToolOptions>): T;
+declare function middleware(session: Session): LanguageModelMiddleware;
+declare function wrapTools<T extends ToolSet>(session: Session, tools: T): T;
 
-export { type PaymentMoments, type WrapToolOptions, middleware, wrapTool, wrapTools };
+export { middleware, wrapTools };

package/dist/ai/index.js

@@ -1,14 +1,13 @@
 import {
-  Sessions,
   recordCall
-} from "../chunk-4MG6VNAU.js";
+} from "../chunk-ZMPKY7AX.js";
 import {
   toJson,
   toJsonObject
 } from "../chunk-FQDHFTVR.js";
 import {
   uuidv7
-} from "../chunk-X3W2Z5GC.js";
+} from "../chunk-77D74TWX.js";
 
 // src/ai/index.ts
 var PARAM_KEYS = [
@@ -23,14 +22,13 @@ var PARAM_KEYS = [
   "responseFormat",
   "stopSequences"
 ];
-function middleware(source) {
-  if (!source) return {};
+function middleware(session) {
   return {
     wrapGenerate: async ({ doGenerate, params, model }) => {
-      const session = await Sessions.resolve(source);
-      if (!session) return doGenerate();
+      const stream = await session.stream();
+      if (!stream) return doGenerate();
       return recordCall(
-        session,
+        stream,
         "llm_call",
         uuidv7(),
         { provider: model.provider, modelId: model.modelId, params: pick(params) },
@@ -44,11 +42,11 @@ function middleware(source) {
     },
     // A stream ends when it drains, not when doStream resolves — so its end is emitted at flush.
     wrapStream: async ({ doStream, params, model }) => {
-      const session = await Sessions.resolve(source);
-      if (!session) return doStream();
+      const evidence = await session.stream();
+      if (!evidence) return doStream();
       const callId = uuidv7();
       const started = Date.now();
-      await session.emit("llm_call.start", {
+      await evidence.emit("llm_call.start", {
         callId,
         provider: model.provider,
         modelId: model.modelId,
@@ -66,7 +64,7 @@ function middleware(source) {
           controller.enqueue(part);
         },
         flush: async () => {
-          await session.emit("llm_call.end", {
+          await evidence.emit("llm_call.end", {
             callId,
             content: toJson(parts),
             ...finish.finishReason ? { finishReason: finish.finishReason } : {},
@@ -79,38 +77,32 @@ function middleware(source) {
     }
   };
 }
-function wrapTool(source, tool, opts = {}) {
-  if (!source || !tool.execute) return tool;
+function wrapTools(session, tools) {
+  const out = {};
+  for (const [name, tool] of Object.entries(tools))
+    out[name] = wrapTool(session, name, tool);
+  return out;
+}
+function wrapTool(session, toolName, tool) {
+  if (!tool.execute) return tool;
   const original = tool.execute;
-  const toolName = opts.name ?? tool.name ?? "tool";
   const execute = async (input, options) => {
-    const session = await Sessions.resolve(source);
-    if (!session) return original(input, options);
+    const stream = await session.stream();
+    if (!stream) return original(input, options);
     return recordCall(
-      session,
+      stream,
       "tool_call",
-      options?.toolCallId ?? uuidv7(),
+      options.toolCallId,
       { toolName, input: toJson(input), transport: "local" },
       async () => {
         const output = await original(input, options);
         return output && typeof output === "object" && Symbol.asyncIterator in output ? collect(output) : output;
       },
-      async (output) => {
-        const moments = opts.payment?.(input, output) ?? null;
-        if (moments?.requested) await session.emit("payment.requested", moments.requested);
-        if (moments?.presented) await session.emit("payment.presented", moments.presented);
-        return { output: toJson(output) };
-      }
+      (output) => ({ output: toJson(output) })
     );
   };
   return { ...tool, execute };
 }
-function wrapTools(source, tools, opts = {}) {
-  const out = {};
-  for (const [name, tool] of Object.entries(tools))
-    out[name] = wrapTool(source, tool, { name, ...opts[name] });
-  return out;
-}
 function pick(params) {
   const out = {};
   for (const k of PARAM_KEYS) {
@@ -126,6 +118,5 @@ async function collect(it) {
 }
 export {
   middleware,
-  wrapTool,
   wrapTools
 };

package/dist/{chunk-X3W2Z5GC.js → chunk-77D74TWX.js}

@@ -305,7 +305,6 @@ export {
   toHex,
   fromHex,
   sha256,
-  canonicalize,
   canonicalBytes,
   payloadDigest,
   memorySigner,

package/dist/{chunk-WY5ZX4BD.js → chunk-IUWC6HT5.js}

@@ -1,22 +1,18 @@
+import {
+  summaryOf
+} from "./chunk-M4I3FGZG.js";
 import {
   toJsonObject
 } from "./chunk-FQDHFTVR.js";
 import {
   payloadDigest
-} from "./chunk-X3W2Z5GC.js";
+} from "./chunk-77D74TWX.js";
 
 // src/x402/binding.ts
 var SESSION_EXTENSION = "beltic.sessionId";
 var SESSION_HEADER = "Beltic-Session-Id";
-var DECISION_EXTENSION = "beltic.decisionId";
 function sessionIdOf(extensions) {
-  return stringAt(extensions, SESSION_EXTENSION);
-}
-function decisionIdOf(extensions) {
-  return stringAt(extensions, DECISION_EXTENSION);
-}
-function stringAt(extensions, key) {
-  const v = extensions?.[key];
+  const v = extensions?.[SESSION_EXTENSION];
   return typeof v === "string" && v.length > 0 ? v : null;
 }
 
@@ -95,24 +91,15 @@ function priceValue(price) {
 }
 
 // src/x402/adapter.ts
-function attachX402(beltic, server, http, opts = {}) {
+function attachX402(beltic, server, http) {
   const inFlight = /* @__PURE__ */ new Map();
-  const resolveSession = async (bound, ctx) => {
-    const key = opts.correlate?.(ctx) ?? null;
-    return bound ?? (key ? await beltic.correlation.resolve(key) : null);
-  };
   http?.onProtectedRequest(async (ctx, route) => {
     if (ctx.paymentHeader) return;
     const bound = ctx.adapter.getHeader(SESSION_HEADER) ?? ctx.adapter.getHeader(SESSION_HEADER.toLowerCase());
-    const sessionId = await resolveSession(bound ?? null, {
-      path: ctx.path,
-      method: ctx.method,
-      header: (n) => ctx.adapter.getHeader(n)
-    });
-    if (!sessionId) return;
-    const session = await beltic.sessions.ensure(sessionId);
+    if (!bound) return;
+    const stream = await beltic.streams.ensure(bound);
     const accepts = Array.isArray(route.accepts) ? route.accepts[0] : route.accepts;
-    await session.emit(
+    await stream.emit(
       "payment.requested",
       x402Moments.route(accepts, {
         path: ctx.path,
@@ -124,54 +111,34 @@ function attachX402(beltic, server, http, opts = {}) {
   server.onBeforeVerify(async (ctx) => {
     const payload = ctx.paymentPayload;
     const requirements = ctx.requirements;
-    const sessionId = await resolveSession(sessionIdOf(payload.extensions), {
-      path: payload.resource?.url ?? "",
-      method: "PAY",
-      header: () => void 0
-    });
-    const session = await beltic.sessions.ensure(sessionId);
-    if (session.born === "seller")
-      await session.emit("payment.requested", x402Moments.requirements(requirements));
+    const stream = await beltic.streams.ensure(sessionIdOf(payload.extensions));
+    if (stream.born === "seller")
+      await stream.emit("payment.requested", x402Moments.requirements(requirements));
     const presented = x402Moments.payload(payload);
-    await session.emit("payment.presented", presented);
-    inFlight.set(payloadDigest(payload), session);
-    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,
-      buyerDecisionId: decisionIdOf(payload.extensions)
-    });
-    if (out.verdict.blocks(beltic.onReview)) {
-      return {
-        abort: true,
-        reason: `BELTIC_${out.verdict.value}`,
-        message: out.reasonCodes.join(",")
-      };
-    }
-    return;
+    await stream.emit("payment.presented", presented);
+    inFlight.set(payloadDigest(payload), stream);
+    const decision = await beltic.evaluate(stream.id, summaryOf(presented));
+    if (decision.absent || decision.allowed) return;
+    return {
+      abort: true,
+      reason: `BELTIC_${decision.value}`,
+      message: decision.reasonCodes.join(",")
+    };
   });
   server.onAfterSettle(async (ctx) => {
     const key = payloadDigest(ctx.paymentPayload);
-    const session = inFlight.get(key);
-    if (!session) return;
+    const stream = inFlight.get(key);
+    if (!stream) return;
     inFlight.delete(key);
-    if (ctx.result.success) await session.close("settled", { transaction: ctx.result.transaction });
+    if (ctx.result.success) await stream.close("settled", { transaction: ctx.result.transaction });
   });
-  return { inFlight };
 }
 
 export {
   SESSION_EXTENSION,
   SESSION_HEADER,
-  DECISION_EXTENSION,
-  sessionIdOf,
-  decisionIdOf,
   x402Currency,
   x402Summary,
-  payerOf,
   x402Moments,
   attachX402
 };

package/dist/chunk-M4I3FGZG.js

@@ -0,0 +1,13 @@
+// src/core/payment-moment.ts
+function summaryOf(m) {
+  return {
+    protocol: m.protocol,
+    payee: m.payee,
+    amount: { value: m.amount.value, currency: m.amount.currency },
+    ...m.payer ? { payer: m.payer } : {}
+  };
+}
+
+export {
+  summaryOf
+};

package/dist/chunk-ZMPKY7AX.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(stream, kind, callId, start) {
+  const started = Date.now();
+  const opened = stream.emit(`${kind}.start`, { callId, ...start });
+  const close = async (outcome) => {
+    await opened;
+    return stream.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(stream, kind, callId, start, run, end = () => ({})) {
+  const span = openCall(stream, 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/client-CgCjOrRP.d.ts

@@ -0,0 +1,65 @@
+import { a7 as PaymentSummary } from './index-IfY4XCvJ.js';
+import { b as SessionOptions, S as Session, a as Decision } from './session-Dcof4UIn.js';
+
+/**
+ * One SDK, two halves (Fraud SDK RFC › Summary). `Beltic` is the single
+ * client: `session` for the buyer half, `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, …)
+ *
+ * Neither half decides risk locally: verdicts are platform-side.
+ *
+ * A client is configured or it is not constructed — `Beltic.fromEnv()`
+ * reads `BELTIC_*`, and there is no disabled client (GAP-78). Evidence is
+ * a side channel of the work it observes, so a platform outage never
+ * throws into that work (GAP-70): the transport waits it out, `session`
+ * runs without a stream, `evaluate` answers `Decision.absent()` — never an
+ * invented verdict. What the platform *rejects* (a 4xx, a forked chain)
+ * is the client's fault and throws.
+ */
+
+declare const SDK_VERSION = "0.6.0";
+interface BelticOptions {
+    apiKey: string;
+    baseUrl: string;
+    /** The agent's 32-byte Ed25519 seed as 64 hex — the buyer half. Without it, `session` is unavailable; the seller half works. */
+    agentSeed?: string | undefined;
+}
+declare class Beltic {
+    private readonly api;
+    private readonly transport;
+    private readonly sessions;
+    /**
+     * The client the environment describes: `BELTIC_API_KEY` and
+     * `BELTIC_BASE_URL`, both required, and `BELTIC_AGENT_SEED` (64 hex) for
+     * the buyer half. A missing required variable is a configuration error,
+     * thrown (GAP-78).
+     */
+    static fromEnv(env?: Record<string, string | undefined>): Beltic;
+    constructor(opts: BelticOptions);
+    /**
+     * The session for a key of the host's own (its session, run or
+     * conversation id) — one object per key until it closes; the options
+     * count on the first call only. See `Session`.
+     */
+    session(key: string, opts?: SessionOptions): Session;
+    /**
+     * The platform's verdict on a payment — the seller's before it verifies,
+     * the buyer's before it presents (Fraud SDK RFC › Evaluation Client).
+     * Read-your-writes: the buffered evidence is flushed first so the
+     * platform judges what the caller already saw (GAP-16). Absent when the
+     * platform could not be reached (GAP-70).
+     */
+    evaluate(sessionId: string, payment: PaymentSummary): Promise<Decision>;
+    /** Send everything buffered now and wait for that attempt. */
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+    /** `process.env` where there is a `process` (Node); `{}` on workerd, where the shell passes its `env`. */
+    private static processEnv;
+}
+
+export { Beltic as B, SDK_VERSION as S, type BelticOptions as a };

package/dist/{verdict-CDAsxktI.d.ts → index-IfY4XCvJ.d.ts}

@@ -529,27 +529,4 @@ interface PayloadByKind {
     'platform.anomaly': PlatformAnomalyPayload;
 }
 
-/**
- * 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 LlmCallEndPayload as $, ALL_SOURCES as A, type EventResultStatus as B, type ChainHead as C, type Decision as D, type EvidenceSourceAll as E, EventResultStatusSchema as F, type EvidenceAck as G, EvidenceAckSchema as H, type EvidenceBatchInput as I, type JsonObject as J, EvidenceBatchInputSchema as K, type EvidenceEnvelope as L, type EvidenceEvent as M, EvidenceEventSchema as N, type EvidenceKind as O, type PaymentMomentPayload as P, EvidenceKindSchema as Q, type EvidenceSource as R, EvidenceSourceAllSchema as S, EvidenceSourceSchema as T, type GatewayDecisionPayload as U, GatewayDecisionPayloadSchema as V, type Hex64 as W, Hex64Schema as X, type IntentDeclaredPayload as Y, IntentDeclaredPayloadSchema as Z, JsonValueSchema as _, type PaymentSummary as a, LlmCallEndPayloadSchema as a0, type LlmCallStartPayload as a1, LlmCallStartPayloadSchema as a2, MAX_BATCH_EVENTS as a3, type OnReview as a4, PAYMENT_ARTIFACTS as a5, PLATFORM_KINDS as a6, type PayloadByKind as a7, PaymentMomentPayloadSchema as a8, PaymentSummarySchema as a9, type WireEvidenceKind as aA, WireEvidenceKindSchema as aB, compareBySessionSource as aC, compareBySourceSeq as aD, isPlatformKind as aE, isWireKind as aF, payloadSchemaFor as aG, type PlatformAnomalyPayload as aa, PlatformAnomalyPayloadSchema as ab, type PlatformEvidenceKind as ac, PlatformEvidenceKindSchema as ad, type PlatformObservationPayload as ae, PlatformObservationPayloadSchema as af, SESSION_CLOSE_REASONS as ag, SOURCE_ORDER as ah, SeqSchema as ai, type SessionClosePayload as aj, SessionClosePayloadSchema as ak, SessionIdSchema as al, type SessionOpenPayload as am, SessionOpenPayloadSchema as an, type Sig as ao, SigSchema as ap, TimestampSchema as aq, type ToolCallEndPayload as ar, ToolCallEndPayloadSchema as as, type ToolCallStartPayload as at, ToolCallStartPayloadSchema as au, type TransportGapPayload as av, TransportGapPayloadSchema as aw, Verdict as ax, WIRE_KINDS as ay, WIRE_SOURCES as az, type JsonValue as b, ANOMALY_TYPES as c, type Amount as d, AmountSchema as e, type ApiError as f, ApiErrorSchema as g, ChainHeadSchema as h, type CreatePolicyInput as i, CreatePolicyInputSchema as j, type CreatePolicyOutput as k, CreatePolicyOutputSchema as l, type CreateSessionInput as m, CreateSessionInputSchema as n, type CreateSessionOutput as o, CreateSessionOutputSchema as p, DecisionSchema as q, type DeclaredIntent as r, DeclaredIntentSchema as s, type DigestedEnvelope as t, type EvaluateInput as u, EvaluateInputSchema as v, type EvaluateOutput as w, EvaluateOutputSchema as x, type EventResult as y, EventResultSchema as z };
+export { type LlmCallStartPayload as $, ALL_SOURCES as A, type EvidenceAck as B, type ChainHead as C, type Decision as D, type EvidenceSourceAll as E, EvidenceAckSchema as F, type EvidenceBatchInput as G, EvidenceBatchInputSchema as H, type EvidenceEnvelope as I, type JsonValue as J, type EvidenceEvent as K, EvidenceEventSchema as L, type EvidenceKind as M, EvidenceKindSchema as N, type EvidenceSource as O, EvidenceSourceAllSchema as P, EvidenceSourceSchema as Q, type GatewayDecisionPayload as R, GatewayDecisionPayloadSchema as S, type Hex64 as T, Hex64Schema as U, type IntentDeclaredPayload as V, IntentDeclaredPayloadSchema as W, type JsonObject as X, JsonValueSchema as Y, type LlmCallEndPayload as Z, LlmCallEndPayloadSchema as _, ANOMALY_TYPES as a, LlmCallStartPayloadSchema as a0, MAX_BATCH_EVENTS as a1, PAYMENT_ARTIFACTS as a2, PLATFORM_KINDS as a3, type PayloadByKind as a4, type PaymentMomentPayload as a5, PaymentMomentPayloadSchema as a6, type PaymentSummary as a7, PaymentSummarySchema as a8, type PlatformAnomalyPayload as a9, compareBySessionSource as aA, compareBySourceSeq as aB, isPlatformKind as aC, isWireKind as aD, payloadSchemaFor as aE, PlatformAnomalyPayloadSchema as aa, type PlatformEvidenceKind as ab, PlatformEvidenceKindSchema as ac, type PlatformObservationPayload as ad, PlatformObservationPayloadSchema as ae, SESSION_CLOSE_REASONS as af, SOURCE_ORDER as ag, SeqSchema as ah, type SessionClosePayload as ai, SessionClosePayloadSchema as aj, SessionIdSchema as ak, type SessionOpenPayload as al, SessionOpenPayloadSchema as am, type Sig as an, SigSchema as ao, TimestampSchema as ap, type ToolCallEndPayload as aq, ToolCallEndPayloadSchema as ar, type ToolCallStartPayload as as, ToolCallStartPayloadSchema as at, type TransportGapPayload as au, TransportGapPayloadSchema as av, WIRE_KINDS as aw, WIRE_SOURCES as ax, type WireEvidenceKind as ay, WireEvidenceKindSchema as az, type Amount as b, AmountSchema as c, type ApiError as d, ApiErrorSchema as e, ChainHeadSchema as f, type CreatePolicyInput as g, CreatePolicyInputSchema as h, type CreatePolicyOutput as i, CreatePolicyOutputSchema as j, type CreateSessionInput as k, CreateSessionInputSchema as l, type CreateSessionOutput as m, CreateSessionOutputSchema as n, DecisionSchema as o, type DeclaredIntent as p, DeclaredIntentSchema as q, type DigestedEnvelope as r, type EvaluateInput as s, EvaluateInputSchema as t, type EvaluateOutput as u, EvaluateOutputSchema as v, type EventResult as w, EventResultSchema as x, type EventResultStatus as y, EventResultStatusSchema as z };

package/dist/index.d.ts

@@ -1,39 +1,18 @@
-import { a as Session } from './session-gK51QVAM.js';
-export { A as AgentIdentity, b as ApiClient, c as ApiClientOptions, B as Beltic, d as BelticApiError, e as BelticOptions, C as ChainRejectedError, f as CorrelationStore, D as DEFAULT_OPEN_RETRY_MS, g as DEFAULT_TRANSPORT, h as DecideOptions, i as Decision, E as Env, j as Evaluation, H as HumanDecisionInput, M as MemoryCorrelationStore, O as OpenSessionInput, R as RedactFn, k as Run, l as RunOptions, m as SDK_VERSION, n as SessionBorn, S as SessionSource, o as Sessions, p as StartSessionInput, T as ToolCallSpan, q as Transport, r as TransportClosedError, s as TransportOptions, t as createBeltic, u as ephemeralIdentity, v as fileIdentity, w as identityFromSeed } from './session-gK51QVAM.js';
-import { a as PaymentSummary, J as JsonObject, P as PaymentMomentPayload } from './verdict-CDAsxktI.js';
+export { B as Beltic, a as BelticOptions, S as SDK_VERSION } from './client-CgCjOrRP.js';
+export { B as BelticApiError, C as ChainRejectedError, D as DecideOptions, a as Decision, H as HumanDecisionInput, S as Session, b as SessionOptions } from './session-Dcof4UIn.js';
+import './index-IfY4XCvJ.js';
 import 'zod';
 
 /**
- * Thrown by the two primitives that cannot fail open (`sessions.start`,
- * `sessions.ensure`) when the client is disabled: a `Beltic.fromEnv` with
- * no `BELTIC_*` configured is a client that records nothing (GAP-78), and
- * a caller that insists on a session gets told so rather than a `null`.
+ * A client that is not configured is a fault of the host, not a state the
+ * SDK runs in: an empty API key, a base URL that does not parse, a buyer
+ * entry with no agent identity, a `BELTIC_*` variable missing. Thrown at
+ * construction or at the first entry that needs the missing piece, and
+ * never absorbed by `failOpen` (GAP-78).
  */
-declare class BelticDisabledError extends Error {
-    readonly code = "SDK_DISABLED";
-    constructor(entry: string);
+declare class BelticConfigError extends Error {
+    readonly code = "CONFIG";
+    constructor(message: string);
 }
 
-/**
- * The shape the platform judges (`PaymentSummary`) and the shape the record
- * keeps (`PaymentMomentPayload`) share their comparable core: payee, amount,
- * payer. Every protocol adapter builds moments through here so the two
- * sides of one purchase compare (`EVIDENCE_MISMATCH`, GAP-50).
- */
-
-declare function summaryOf(m: PaymentSummary | PaymentMomentPayload): PaymentSummary;
-/** A presentation the seller side saw as a signed payment, in any protocol. */
-declare function presentedFrom(summary: PaymentSummary, raw: JsonObject): PaymentMomentPayload;
-
-/**
- * One instrumented call = a `*.start` event, the work, a `*.end` event
- * carrying the outcome or the error (GAP-07 correlates them by `callId`).
- * `openCall` is the span; `recordCall` runs the work inside one. The AI
- * middleware, the tool wrapper, the MCP client and a host's own tool loop
- * (`Session.toolCall`) all record the same way.
- */
-
-type CallKind = 'llm_call' | 'tool_call';
-declare function recordCall<T>(session: Session, kind: CallKind, callId: string, start: JsonObject, run: () => PromiseLike<T>, end?: (result: T) => Promise<JsonObject> | JsonObject): Promise<T>;
-
-export { BelticDisabledError, type CallKind, Session, presentedFrom, recordCall, summaryOf };
+export { BelticConfigError };