@belticlabs/agent-risk-sdk 0.5.0 → 0.7.0

package/dist/{chunk-GM4KEEZB.js → chunk-HI656UWG.js}

@@ -1,29 +1,26 @@
+import {
+  summaryOf
+} from "./chunk-M4I3FGZG.js";
 import {
   toJsonObject
 } from "./chunk-FQDHFTVR.js";
 import {
   payloadDigest
-} from "./chunk-X3W2Z5GC.js";
+} from "./chunk-UXXSE643.js";
+import {
+  Money
+} from "./chunk-FNU4CRJJ.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;
 }
 
 // src/x402/moments.ts
-function x402Currency(network, asset) {
-  return `${network}/${asset}`;
-}
+import { z } from "zod";
 function x402Summary(accepts, opts = {}) {
   const payer = opts.payer?.toLowerCase();
   return {
@@ -31,7 +28,7 @@ function x402Summary(accepts, opts = {}) {
     payee: accepts?.payTo ?? "unknown",
     amount: {
       value: accepts?.amount ?? "0",
-      currency: accepts ? x402Currency(accepts.network ?? "unknown", accepts.asset ?? "unknown") : "unknown"
+      currency: accepts ? Money.x402Currency(accepts.network ?? "unknown", accepts.asset ?? "unknown") : "unknown"
     },
     ...payer ? { payer } : {}
   };
@@ -68,7 +65,7 @@ var x402Moments = {
     return fromAccepts(
       {
         payTo: typeof accepts.payTo === "string" ? accepts.payTo : "dynamic",
-        amount: priceValue(accepts.price),
+        amount: PriceSchema.parse(accepts.price),
         network: accepts.network,
         asset: extra?.asset ?? "route"
       },
@@ -86,24 +83,22 @@ var x402Moments = {
     );
   }
 };
-function priceValue(price) {
-  if (typeof price === "string") return price.replace(/[^0-9.]/g, "") || "0";
-  if (typeof price === "number") return String(price);
-  if (price && typeof price === "object" && typeof price.amount === "string")
-    return price.amount;
-  return "0";
-}
+var PriceSchema = z.union([
+  z.string().transform((s) => s.replace(/[^0-9.]/g, "") || "0"),
+  z.number().transform(String),
+  z.object({ amount: z.string() }).transform((p) => p.amount)
+]).catch("0");
 
 // src/x402/adapter.ts
-function attachX402(beltic, server, http, opts = {}) {
+function attachX402(beltic, server, http) {
   const inFlight = /* @__PURE__ */ new Map();
   http?.onProtectedRequest(async (ctx, route) => {
     if (ctx.paymentHeader) return;
     const bound = ctx.adapter.getHeader(SESSION_HEADER) ?? ctx.adapter.getHeader(SESSION_HEADER.toLowerCase());
     if (!bound) return;
-    const session = await beltic.sessions.ensure(bound);
+    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,
@@ -115,49 +110,33 @@ function attachX402(beltic, server, http, opts = {}) {
   server.onBeforeVerify(async (ctx) => {
     const payload = ctx.paymentPayload;
     const requirements = ctx.requirements;
-    const session = await beltic.sessions.ensure(sessionIdOf(payload.extensions));
-    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-JGVVQUXQ.js

@@ -0,0 +1,38 @@
+// 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(span, run, end = () => ({})) {
+  await span.opened;
+  try {
+    const result = await run();
+    await span.end(await end(result));
+    return result;
+  } catch (err) {
+    await span.fail(err);
+    throw err;
+  }
+}
+
+export {
+  openCall,
+  recordCall
+};

package/dist/chunk-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-X3W2Z5GC.js → chunk-UXXSE643.js}

@@ -9,28 +9,6 @@ function uuidv7(now = Date.now()) {
   return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
 }
 
-// ../canon/src/base58.ts
-var ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-var MAP = new Map([...ALPHABET].map((c, i) => [c, i]));
-function base58Encode(bytes) {
-  let zeros = 0;
-  while (zeros < bytes.length && bytes[zeros] === 0) zeros++;
-  const digits = [];
-  for (let i = zeros; i < bytes.length; i++) {
-    let carry = bytes[i];
-    for (let j = 0; j < digits.length; j++) {
-      carry += digits[j] << 8;
-      digits[j] = carry % 58;
-      carry = carry / 58 | 0;
-    }
-    while (carry > 0) {
-      digits.push(carry % 58);
-      carry = carry / 58 | 0;
-    }
-  }
-  return "1".repeat(zeros) + digits.reverse().map((d) => ALPHABET[d]).join("");
-}
-
 // ../canon/src/encoding.ts
 function toHex(buf) {
   return Buffer.from(buf).toString("hex");
@@ -293,6 +271,28 @@ var Chain = class _Chain {
   }
 };
 
+// ../canon/src/base58.ts
+var ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var MAP = new Map([...ALPHABET].map((c, i) => [c, i]));
+function base58Encode(bytes) {
+  let zeros = 0;
+  while (zeros < bytes.length && bytes[zeros] === 0) zeros++;
+  const digits = [];
+  for (let i = zeros; i < bytes.length; i++) {
+    let carry = bytes[i];
+    for (let j = 0; j < digits.length; j++) {
+      carry += digits[j] << 8;
+      digits[j] = carry % 58;
+      carry = carry / 58 | 0;
+    }
+    while (carry > 0) {
+      digits.push(carry % 58);
+      carry = carry / 58 | 0;
+    }
+  }
+  return "1".repeat(zeros) + digits.reverse().map((d) => ALPHABET[d]).join("");
+}
+
 // ../canon/src/did-key.ts
 var ED25519_PUB_MULTICODEC = Buffer.from([237, 1]);
 var PREFIX = "did:key:z";
@@ -301,11 +301,13 @@ function didKeyFromEd25519(publicKey) {
   return PREFIX + base58Encode(Buffer.concat([ED25519_PUB_MULTICODEC, Buffer.from(publicKey)]));
 }
 
+// ../canon/src/session-id.ts
+import { randomBytes as randomBytes2 } from "crypto";
+
 export {
   toHex,
   fromHex,
   sha256,
-  canonicalize,
   canonicalBytes,
   payloadDigest,
   memorySigner,

package/dist/client-Xn9M58OJ.d.ts

@@ -0,0 +1,71 @@
+import { N as PaymentSummary } from './index-DAVKGJs5.js';
+import { b as SessionOptions, S as Session, a as Decision } from './session-DAN29XoB.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.7.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;
+    /** Open handles by conversation id (GAP-84). */
+    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);
+    /**
+     * A conversation: new without an id, resumed with one — the id `session.id()`
+     * answered in this or any earlier process (GAP-84). One handle per
+     * conversation in-process until it closes; the options count when a
+     * session is opened. See `Session`.
+     */
+    session(id?: 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 session's buffered evidence is flushed first so
+     * the platform judges what the caller already saw (GAP-16/88). With a `callId`
+     * the platform answers the decision already taken for that call anywhere
+     * in the conversation (GAP-84). Absent when the platform could not be
+     * reached (GAP-70).
+     */
+    evaluate(sessionId: string, payment: PaymentSummary, opts?: {
+        callId?: string | undefined;
+    }): Promise<Decision>;
+    /** Send everything buffered now — every session's — 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 };