@belticlabs/agent-risk-sdk 0.6.0 → 0.8.0

package/dist/ai/index.d.ts

@@ -1,6 +1,6 @@
 import { LanguageModelMiddleware, ToolSet } from 'ai';
-import { S as Session } from '../session-Dcof4UIn.js';
-import '../index-IfY4XCvJ.js';
+import { S as Session } from '../session-DTIzd1EQ.js';
+import '../index-CBUSXzgG.js';
 import 'zod';
 
 declare function middleware(session: Session): LanguageModelMiddleware;

package/dist/ai/index.js

@@ -1,13 +1,12 @@
 import {
   recordCall
-} from "../chunk-ZMPKY7AX.js";
+} from "../chunk-JGVVQUXQ.js";
 import {
   toJson,
-  toJsonObject
-} from "../chunk-FQDHFTVR.js";
-import {
+  toJsonObject,
   uuidv7
-} from "../chunk-77D74TWX.js";
+} from "../chunk-MWXXX35V.js";
+import "../chunk-PDE55ZZV.js";
 
 // src/ai/index.ts
 var PARAM_KEYS = [
@@ -28,10 +27,12 @@ function middleware(session) {
       const stream = await session.stream();
       if (!stream) return doGenerate();
       return recordCall(
-        stream,
-        "llm_call",
-        uuidv7(),
-        { provider: model.provider, modelId: model.modelId, params: pick(params) },
+        stream.llmCall({
+          callId: uuidv7(),
+          provider: model.provider,
+          modelId: model.modelId,
+          params: pick(params)
+        }),
         doGenerate,
         (result) => ({
           content: toJson(result.content),
@@ -44,14 +45,13 @@ function middleware(session) {
     wrapStream: async ({ doStream, params, model }) => {
       const evidence = await session.stream();
       if (!evidence) return doStream();
-      const callId = uuidv7();
-      const started = Date.now();
-      await evidence.emit("llm_call.start", {
-        callId,
+      const span = evidence.llmCall({
+        callId: uuidv7(),
         provider: model.provider,
         modelId: model.modelId,
         params: pick(params)
       });
+      await span.opened;
       const { stream, ...rest } = await doStream();
       const parts = [];
       let finish = {};
@@ -64,12 +64,10 @@ function middleware(session) {
           controller.enqueue(part);
         },
         flush: async () => {
-          await evidence.emit("llm_call.end", {
-            callId,
+          await span.end({
             content: toJson(parts),
             ...finish.finishReason ? { finishReason: finish.finishReason } : {},
-            ...finish.usage ? { usage: toJsonObject(finish.usage) } : {},
-            durationMs: Date.now() - started
+            ...finish.usage ? { usage: toJsonObject(finish.usage) } : {}
           });
         }
       });
@@ -90,10 +88,7 @@ function wrapTool(session, toolName, tool) {
     const stream = await session.stream();
     if (!stream) return original(input, options);
     return recordCall(
-      stream,
-      "tool_call",
-      options.toolCallId,
-      { toolName, input: toJson(input), transport: "local" },
+      stream.toolCall({ callId: options.toolCallId, toolName, input: toJson(input) }),
       async () => {
         const output = await original(input, options);
         return output && typeof output === "object" && Symbol.asyncIterator in output ? collect(output) : output;

package/dist/chunk-DI3LZR65.js

@@ -0,0 +1,103 @@
+import {
+  toJsonObject
+} from "./chunk-MWXXX35V.js";
+import {
+  Money
+} from "./chunk-PDE55ZZV.js";
+
+// 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;
+}
+
+// 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 } : {}
+  };
+}
+
+// src/x402/moments.ts
+import { z } from "zod";
+function summary(accepts, opts = {}) {
+  const payer = opts.payer?.toLowerCase();
+  return {
+    protocol: "x402",
+    payee: accepts?.payTo ?? "unknown",
+    amount: {
+      value: accepts?.amount ?? "0",
+      currency: accepts ? Money.x402Currency(accepts.network ?? "unknown", accepts.asset ?? "unknown") : "unknown"
+    },
+    ...payer ? { payer } : {}
+  };
+}
+function fromAccepts(a, artifact, raw, payer) {
+  return { ...summary(a, { payer }), artifact, raw };
+}
+function payerOf(payload) {
+  const p = payload.payload ?? {};
+  const auth = p.authorization;
+  const candidates = [
+    auth?.from,
+    p.from,
+    p.payer,
+    p.signer,
+    p.permit?.owner
+  ];
+  const hit = candidates.find((c) => typeof c === "string" && c.length > 0);
+  return typeof hit === "string" ? hit.toLowerCase() : void 0;
+}
+var x402Moments = {
+  summary,
+  /** The 402 challenge as the buyer saw it, from the `PAYMENT-REQUIRED` header. */
+  required(required) {
+    return fromAccepts(required.accepts?.[0], "http-402", toJsonObject(required));
+  },
+  /** The requirements the seller's resource server resolved for a request. */
+  requirements(req) {
+    return fromAccepts(req, "http-402", toJsonObject(req));
+  },
+  /** A route's static `accepts` config, before any payment header exists. */
+  route(route, raw) {
+    const accepts = route ?? {};
+    const extra = accepts.extra;
+    return fromAccepts(
+      {
+        payTo: typeof accepts.payTo === "string" ? accepts.payTo : "dynamic",
+        amount: PriceSchema.parse(accepts.price),
+        network: accepts.network,
+        asset: extra?.asset ?? "route"
+      },
+      "http-402",
+      raw
+    );
+  },
+  /** The signed payment the buyer presented, with the requirement it accepted. */
+  payload(payload) {
+    return fromAccepts(
+      payload.accepted,
+      "payment-signature",
+      toJsonObject(payload),
+      payerOf(payload)
+    );
+  }
+};
+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");
+
+export {
+  summaryOf,
+  SESSION_EXTENSION,
+  SESSION_HEADER,
+  sessionIdOf,
+  x402Moments
+};

package/dist/{chunk-ZMPKY7AX.js → chunk-JGVVQUXQ.js}

@@ -20,8 +20,7 @@ function openCall(stream, kind, callId, start) {
     fail: (error, outcome = {}) => close({ error: errorOf(error), ...outcome })
   };
 }
-async function recordCall(stream, kind, callId, start, run, end = () => ({})) {
-  const span = openCall(stream, kind, callId, start);
+async function recordCall(span, run, end = () => ({})) {
   await span.opened;
   try {
     const result = await run();

package/dist/{chunk-77D74TWX.js → chunk-MWXXX35V.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,6 +301,34 @@ 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";
+
+// src/core/json.ts
+function toJson(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value === "bigint") return value.toString();
+  if (value instanceof Uint8Array) return { $bytes: Buffer.from(value).toString("base64") };
+  if (value instanceof Date) return value.toISOString();
+  if (value instanceof URL) return value.toString();
+  if (Array.isArray(value)) return value.map(toJson);
+  if (typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (v === void 0 || typeof v === "function") continue;
+      out[k] = toJson(v);
+    }
+    return out;
+  }
+  return null;
+}
+function toJsonObject(value) {
+  const j = toJson(value);
+  return j && typeof j === "object" && !Array.isArray(j) ? j : { value: j };
+}
+
 export {
   toHex,
   fromHex,
@@ -310,5 +338,7 @@ export {
   memorySigner,
   Chain,
   didKeyFromEd25519,
-  uuidv7
+  uuidv7,
+  toJson,
+  toJsonObject
 };

package/dist/chunk-P3VZNH5W.js

@@ -0,0 +1,57 @@
+import {
+  SESSION_HEADER,
+  sessionIdOf,
+  summaryOf,
+  x402Moments
+} from "./chunk-DI3LZR65.js";
+import {
+  payloadDigest
+} from "./chunk-MWXXX35V.js";
+
+// src/x402/adapter.ts
+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 stream = await beltic.streams.ensure(bound);
+    const accepts = Array.isArray(route.accepts) ? route.accepts[0] : route.accepts;
+    await stream.emit(
+      "payment.requested",
+      x402Moments.route(accepts, {
+        path: ctx.path,
+        method: ctx.method,
+        route: JSON.parse(JSON.stringify(route))
+      })
+    );
+  });
+  server.onBeforeVerify(async (ctx) => {
+    const payload = ctx.paymentPayload;
+    const requirements = ctx.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 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 stream = inFlight.get(key);
+    if (!stream) return;
+    inFlight.delete(key);
+    if (ctx.result.success) await stream.close("settled", { transaction: ctx.result.transaction });
+  });
+}
+
+export {
+  attachX402
+};