@belticlabs/agent-risk-sdk 0.5.0 → 0.7.0

package/dist/{chunk-4BUUPU3O.js → chunk-FNU4CRJJ.js}

@@ -12,6 +12,21 @@ var SOURCE_ORDER = {
 function compareBySourceSeq(a, b) {
   return SOURCE_ORDER[a.source] - SOURCE_ORDER[b.source] || a.seq - b.seq;
 }
+function chainKey(sessionId, source) {
+  return `${sessionId}:${source}`;
+}
+function compareByArrival(a, b) {
+  return a.ts.localeCompare(b.ts) || a.receivedAt.localeCompare(b.receivedAt) || a.sessionId.localeCompare(b.sessionId) || compareBySourceSeq(a, b);
+}
+function compareRootFirst(conversationId) {
+  return (a, b) => Number(b.id === conversationId) - Number(a.id === conversationId);
+}
+function withinHeads(heads) {
+  return (e) => {
+    const cap = heads[chainKey(e.sessionId, e.source)];
+    return cap !== void 0 && e.seq <= cap;
+  };
+}
 function compareBySessionSource(a, b) {
   return a.sessionId < b.sessionId ? -1 : a.sessionId > b.sessionId ? 1 : SOURCE_ORDER[a.source] - SOURCE_ORDER[b.source];
 }
@@ -34,7 +49,12 @@ var PlatformEvidenceKindSchema = z.enum(PLATFORM_KINDS);
 var EvidenceKindSchema = z.enum([...WIRE_KINDS, ...PLATFORM_KINDS]);
 var Hex64Schema = z.string().regex(/^[0-9a-f]{64}$/, "expected 64 lowercase hex chars");
 var SigSchema = z.string().regex(/^ed25519:[A-Za-z0-9_-]{86}$/, "expected ed25519:<base64url>");
-var SessionIdSchema = z.uuid();
+var SESSION_ID_PREFIX = "sess_";
+var SESSION_ID_CHARS = 22;
+var SessionIdSchema = z.string().regex(
+  new RegExp(`^${SESSION_ID_PREFIX}[0-9A-Za-z]{${SESSION_ID_CHARS}}$`),
+  `expected ${SESSION_ID_PREFIX} followed by ${SESSION_ID_CHARS} base62 chars`
+);
 var SeqSchema = z.number().int().min(0);
 var TimestampSchema = z.iso.datetime({ offset: false });
 var JsonValueSchema = z.lazy(
@@ -57,46 +77,99 @@ var EvidenceEventSchema = z.strictObject({
   prevHash: Hex64Schema,
   sig: SigSchema.optional()
 });
-function isWireKind(kind) {
-  return WIRE_KINDS.includes(kind);
-}
-function isPlatformKind(kind) {
-  return PLATFORM_KINDS.includes(kind);
-}
+
+// ../protocol/src/money.ts
+import { z as z2 } from "zod";
+var DecimalStringSchema = z2.string().regex(/^\d+(\.\d+)?$/, "expected a decimal string");
+var AmountSchema = z2.strictObject({
+  /** Decimal string — never a float. For x402 this is the atomic amount (GAP-49). */
+  value: DecimalStringSchema,
+  /** ISO code, or `<network>/<asset>` for on-chain rails (GAP-49). */
+  currency: z2.string().min(1).max(128)
+});
+var ComparableSchema = z2.union([
+  DecimalStringSchema.transform((value) => ({ value, currency: null })),
+  z2.number().finite().transform(String).pipe(DecimalStringSchema).transform((value) => ({ value, currency: null })),
+  z2.object({ value: DecimalStringSchema, currency: z2.string().optional() }).transform((a) => ({ value: a.value, currency: a.currency ?? null }))
+]);
+var Money = class _Money {
+  constructor(value, currency) {
+    this.value = value;
+    this.currency = currency;
+  }
+  static of(amount) {
+    return new _Money(DecimalStringSchema.parse(amount.value), amount.currency);
+  }
+  /** A decimal with no currency: a bound in a rule, a running total. */
+  static bare(value) {
+    return new _Money(DecimalStringSchema.parse(value), null);
+  }
+  /** An x402 amount: atomic units of `asset` on `network`, its currency `<network>/<asset>` (GAP-49). */
+  static x402(network, asset, atomic) {
+    return new _Money(
+      DecimalStringSchema.parse(atomic.toString()),
+      _Money.x402Currency(network, asset)
+    );
+  }
+  static x402Currency(network, asset) {
+    return `${network}/${asset}`;
+  }
+  /** Anything a selector or a rule param may resolve to; null when it is not an amount. */
+  static parse(v) {
+    const r = ComparableSchema.safeParse(v);
+    return r.success ? new _Money(r.data.value, r.data.currency) : null;
+  }
+  comparable(other) {
+    return this.currency === null || other.currency === null || this.currency === other.currency;
+  }
+  compareTo(other) {
+    const [a, b] = _Money.scaled(this.value, other.value);
+    return a < b ? -1 : a > b ? 1 : 0;
+  }
+  exceeds(other) {
+    return this.compareTo(other) > 0;
+  }
+  plus(other) {
+    const [a, b, scale] = _Money.scaled(this.value, other.value);
+    const digits = (a + b).toString().padStart(scale + 1, "0");
+    const int = digits.slice(0, digits.length - scale);
+    const frac = digits.slice(digits.length - scale);
+    return new _Money(scale ? `${int}.${frac}` : int, this.currency);
+  }
+  isZero() {
+    return this.toNumber() === 0;
+  }
+  /** Numeric view for ratios; precision loss is acceptable for a ratio. */
+  toNumber() {
+    return Number(this.value);
+  }
+  /** this / other, or null when `other` is zero. */
+  ratioTo(other) {
+    return other.isZero() ? null : this.toNumber() / other.toNumber();
+  }
+  toAmount() {
+    if (this.currency === null) throw new TypeError("an amount needs a currency");
+    return { value: this.value, currency: this.currency };
+  }
+  static scaled(a, b) {
+    const [ai, af = ""] = a.split(".");
+    const [bi, bf = ""] = b.split(".");
+    const scale = Math.max(af.length, bf.length);
+    return [
+      BigInt(`${ai}${af.padEnd(scale, "0")}`),
+      BigInt(`${bi}${bf.padEnd(scale, "0")}`),
+      scale
+    ];
+  }
+};
 
 // ../protocol/src/reason-codes.ts
-var INDICATOR_CODES = [
-  "CHAIN_BROKEN",
-  "EVIDENCE_MISMATCH",
-  "CREDENTIAL_REVOKED",
-  "SESSION_INVALID",
-  "PRINCIPAL_FLAGGED"
-];
+var INDICATOR_CODES = ["CHAIN_BROKEN", "EVIDENCE_MISMATCH", "SESSION_INVALID"];
 var ANNOTATION_CODES = ["NO_AGENT_TRACE", "NO_POLICY"];
-var COLLECTOR_CODES = [
-  "SCHEMA_INVALID",
-  "SESSION_UNKNOWN",
-  "SESSION_CLOSED",
-  "SESSION_EXPIRED",
-  "SOURCE_FORBIDDEN",
-  "KIND_FORBIDDEN",
-  "SEQ_GAP",
-  "PREV_HASH_MISMATCH",
-  "SIG_MISSING",
-  "SIG_INVALID",
-  "PAYLOAD_INVALID",
-  "EVENT_TOO_LARGE"
-];
-var DEFAULT_RULE_CODES = [
-  "CAP_EXCEEDED",
-  "PAYEE_NOT_ALLOWED",
-  "NO_INTENT",
-  "INTENT_EXPIRED"
-];
 var REASON_CODE_PATTERN = /^[A-Z][A-Z0-9_]{1,63}$/;
 
 // ../protocol/src/selector.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 var SelectorSyntaxError = class extends Error {
   constructor(input, at, detail) {
     super(`invalid selector "${input}" at ${at}: ${detail}`);
@@ -192,20 +265,6 @@ function parseSelector(input) {
     "unknown root (payment | intent | session | signal[name=\u2026] | evidence[\u2026])"
   );
 }
-function formatSelector(sel) {
-  const path = sel.path.map((p) => "key" in p ? `.${p.key}` : `[${p.index}]`).join("");
-  switch (sel.root) {
-    case "payment":
-    case "intent":
-    case "session":
-      return `${sel.root}${path}`;
-    case "signal":
-      return `signal[name=${sel.name}]${path}`;
-    case "evidence":
-      if (sel.kind === "*") return `evidence[*]${path}`;
-      return `evidence[kind=${sel.kind}${sel.source ? `,source=${sel.source}` : ""}]${sel.all ? "[*]" : ""}${path}`;
-  }
-}
 function isSelectorRef(value) {
   return typeof value === "string" && value.startsWith("@") && value.length > 1;
 }
@@ -226,7 +285,7 @@ function walkPath(value, path) {
   }
   return cur;
 }
-var SelectorStringSchema = z2.string().refine(
+var SelectorStringSchema = z3.string().refine(
   (s) => {
     try {
       parseSelector(s);
@@ -239,156 +298,126 @@ var SelectorStringSchema = z2.string().refine(
 );
 
 // ../protocol/src/policy.ts
-import { z as z3 } from "zod";
-var PRIMITIVES = ["THRESHOLD", "MEMBERSHIP", "MATCH", "PRESENCE", "FRESHNESS"];
-var PrimitiveSchema = z3.enum(PRIMITIVES);
-var RuleVerdictSchema = z3.enum(["DENY", "REVIEW"]);
-var RuleSchema = z3.strictObject({
-  id: z3.string().min(1).max(64),
+import { z as z4 } from "zod";
+var PrimitiveSchema = z4.enum(["THRESHOLD", "MEMBERSHIP", "MATCH", "PRESENCE", "FRESHNESS"]);
+var RuleVerdictSchema = z4.enum(["DENY", "REVIEW"]);
+var RuleSchema = z4.strictObject({
+  id: z4.string().min(1).max(64),
   primitive: PrimitiveSchema,
   selector: SelectorStringSchema,
-  params: z3.record(z3.string(), JsonValueSchema),
+  params: z4.record(z4.string(), JsonValueSchema),
   onFail: RuleVerdictSchema,
   /** What to do when the selector (or a `@ref`) resolves to nothing. Default: skip (GAP-44). */
-  onMissing: z3.enum(["skip", "DENY", "REVIEW"]).optional(),
+  onMissing: z4.enum(["skip", "DENY", "REVIEW"]).optional(),
   /** Reason code surfaced to the caller when the rule fails (GAP-44). */
-  code: z3.string().regex(REASON_CODE_PATTERN)
+  code: z4.string().regex(REASON_CODE_PATTERN)
 });
-var PolicyRulesSchema = z3.strictObject({
-  rules: z3.array(RuleSchema).max(200).refine((rules) => new Set(rules.map((r) => r.id)).size === rules.length, {
+var PolicyRulesSchema = z4.strictObject({
+  rules: z4.array(RuleSchema).max(200).refine((rules) => new Set(rules.map((r) => r.id)).size === rules.length, {
     message: "rule ids must be unique"
-  }),
-  /** Domain-score thresholds — the only configurable part of the scores layer. */
-  scoreThresholds: z3.record(z3.string(), z3.number().min(0).max(1)).optional()
+  })
 });
 
 // ../protocol/src/api.ts
-import { z as z4 } from "zod";
-var AmountSchema = z4.strictObject({
-  /** Decimal string — never a float. For x402 this is the atomic amount (GAP-49). */
-  value: z4.string().regex(/^\d+(\.\d+)?$/, "expected a decimal string"),
-  /** ISO code, or `<network>/<asset>` for on-chain rails (GAP-49). */
-  currency: z4.string().min(1).max(128)
-});
-var DeclaredIntentSchema = z4.strictObject({
-  mandate: z4.string().min(1).max(4e3),
+import { z as z5 } from "zod";
+var DeclaredIntentSchema = z5.strictObject({
+  mandate: z5.string().min(1).max(4e3),
   maxAmount: AmountSchema.optional(),
-  merchantAllowlist: z4.array(z4.string().min(1)).optional(),
+  merchantAllowlist: z5.array(z5.string().min(1)).optional(),
   validUntil: TimestampSchema
 });
-var CreateSessionInputSchema = z4.strictObject({
+var CreateSessionInputSchema = z5.strictObject({
   source: EvidenceSourceSchema,
-  /** Buyer-born sessions. `credential` is opaque this phase (GAP-11). */
-  agent: z4.strictObject({ did: z4.string().min(1), credential: z4.string().min(1) }).optional(),
-  intent: DeclaredIntentSchema.optional()
-});
-var CreateSessionOutputSchema = z4.strictObject({
-  sessionId: SessionIdSchema,
-  expiresAt: TimestampSchema
-});
+  /** Buyer-born sessions. `credential` is accepted and not kept: the DID is the credential (GAP-11). */
+  agent: z5.strictObject({ did: z5.string().min(1), credential: z5.string().min(1) }).optional(),
+  intent: DeclaredIntentSchema.optional(),
+  /** Any session of a conversation to continue: the new session joins it as a fresh chain (GAP-84). AGENT_TRACE only. */
+  resume: SessionIdSchema.optional()
+}).describe("session input");
 var MAX_BATCH_EVENTS = 500;
-var EvidenceBatchInputSchema = z4.array(EvidenceEventSchema).min(1).max(MAX_BATCH_EVENTS);
-var EventResultStatusSchema = z4.enum(["ok", "duplicate", "fork", "rejected"]);
-var EventResultSchema = z4.strictObject({
-  index: z4.number().int().min(0),
-  sessionId: SessionIdSchema.nullable(),
-  source: EvidenceSourceSchema.nullable(),
-  seq: z4.number().int().min(0).nullable(),
-  status: EventResultStatusSchema,
-  code: z4.string().optional(),
-  eventDigest: Hex64Schema.optional()
-});
-var ChainHeadSchema = z4.strictObject({
-  seq: z4.number().int().min(0),
-  digest: Hex64Schema
-});
-var EvidenceAckSchema = z4.strictObject({
-  results: z4.array(EventResultSchema),
-  /** Head of every chain touched by the batch, after the batch. Keyed `sessionId:source`. */
-  heads: z4.record(z4.string(), ChainHeadSchema)
-});
-var PaymentSummarySchema = z4.strictObject({
-  protocol: z4.string().min(1),
-  payee: z4.string().min(1),
+var EvidenceBatchInputSchema = z5.array(z5.unknown()).min(1).max(MAX_BATCH_EVENTS).describe("evidence batch");
+var PaymentSummarySchema = z5.strictObject({
+  protocol: z5.string().min(1),
+  payee: z5.string().min(1),
   amount: AmountSchema,
   /** Not in the RFC; needed by `principal-links` and `EVIDENCE_MISMATCH` (GAP-06). */
-  payer: z4.string().min(1).optional()
-});
-var EvaluateInputSchema = z4.strictObject({
-  sessionId: SessionIdSchema,
-  payment: PaymentSummarySchema
+  payer: z5.string().min(1).optional()
 });
-var DecisionSchema = z4.enum(["ALLOW", "DENY", "REVIEW"]);
-var EvaluateOutputSchema = z4.strictObject({
-  decision: DecisionSchema,
-  reasonCodes: z4.array(z4.string().regex(REASON_CODE_PATTERN)),
+var EvaluateInputSchema = z5.strictObject({
   sessionId: SessionIdSchema,
-  /** Additive (GAP-21). */
-  decisionId: z4.uuid()
-});
-var CreatePolicyInputSchema = z4.strictObject({ rules: PolicyRulesSchema });
-var CreatePolicyOutputSchema = z4.strictObject({
-  policyId: z4.uuid(),
-  version: z4.number().int().min(1),
-  status: z4.enum(["ACTIVE", "SUPERSEDED", "DRAFT"])
-});
-var ApiErrorSchema = z4.strictObject({
-  error: z4.strictObject({
-    code: z4.string().min(1),
-    message: z4.string().min(1),
+  payment: PaymentSummarySchema,
+  /** The caller's own id for the call under decision: the same id within one conversation reads the decision already taken (GAP-84). */
+  callId: z5.string().min(1).max(256).optional()
+}).describe("evaluate input");
+var CreatePolicyInputSchema = z5.strictObject({ rules: PolicyRulesSchema }).describe("policy input");
+var ApiErrorSchema = z5.strictObject({
+  error: z5.strictObject({
+    code: z5.string().min(1),
+    message: z5.string().min(1),
     details: JsonValueSchema.optional(),
-    request_id: z4.string().optional()
+    request_id: z5.string().optional()
   })
 });
 
 // ../protocol/src/payloads/index.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var Json = JsonValueSchema;
-var JsonRecord = z5.record(z5.string(), Json);
-var SessionOpenPayloadSchema = z5.looseObject({
-  runtime: z5.looseObject({
-    sdk: z5.string().min(1),
-    version: z5.string().min(1),
-    framework: z5.string().optional(),
-    model: z5.string().optional()
+var JsonRecord = z6.record(z6.string(), Json);
+var SessionOpenPayloadSchema = z6.looseObject({
+  runtime: z6.looseObject({
+    sdk: z6.string().min(1),
+    version: z6.string().min(1),
+    framework: z6.string().optional(),
+    model: z6.string().optional()
   }),
   /** Runtime / repo attestations read by the (staged) Attestation Assurance score. */
   attestations: JsonRecord.optional()
 });
 var SESSION_CLOSE_REASONS = ["completed", "settled", "aborted", "expired"];
-var SessionClosePayloadSchema = z5.looseObject({
-  reason: z5.enum(SESSION_CLOSE_REASONS),
-  transaction: z5.string().optional()
+var SessionClosePayloadSchema = z6.looseObject({
+  reason: z6.enum(SESSION_CLOSE_REASONS),
+  transaction: z6.string().optional()
 });
 var IntentDeclaredPayloadSchema = DeclaredIntentSchema.loose();
-var LlmCallStartPayloadSchema = z5.looseObject({
-  callId: z5.string().min(1),
+var PromptDeltaSchema = z6.strictObject({
+  prior: z6.string().min(1),
+  shared: z6.number().int().min(0),
+  messages: z6.array(Json)
+});
+var LlmCallParamsSchema = z6.looseObject({
+  prompt: Json.optional(),
+  promptDelta: PromptDeltaSchema.optional()
+}).refine((p) => p.prompt === void 0 || p.promptDelta === void 0, {
+  message: "params carries prompt or promptDelta, not both"
+});
+var LlmCallStartPayloadSchema = z6.looseObject({
+  callId: z6.string().min(1),
   // GAP-07
-  provider: z5.string().min(1),
-  modelId: z5.string().min(1),
-  params: JsonRecord
+  provider: z6.string().min(1),
+  modelId: z6.string().min(1),
+  params: LlmCallParamsSchema
 });
-var LlmCallEndPayloadSchema = z5.looseObject({
-  callId: z5.string().min(1),
+var LlmCallEndPayloadSchema = z6.looseObject({
+  callId: z6.string().min(1),
   content: Json.optional(),
-  finishReason: z5.string().optional(),
+  finishReason: z6.string().optional(),
   usage: JsonRecord.optional(),
-  durationMs: z5.number().int().min(0),
-  error: z5.looseObject({ name: z5.string(), message: z5.string() }).optional()
+  durationMs: z6.number().int().min(0),
+  error: z6.looseObject({ name: z6.string(), message: z6.string() }).optional()
 });
-var ToolCallStartPayloadSchema = z5.looseObject({
-  callId: z5.string().min(1),
+var ToolCallStartPayloadSchema = z6.looseObject({
+  callId: z6.string().min(1),
   // GAP-07
-  toolName: z5.string().min(1),
+  toolName: z6.string().min(1),
   input: Json,
-  transport: z5.enum(["local", "mcp"]).optional(),
-  server: z5.string().optional()
+  transport: z6.enum(["local", "mcp"]).optional(),
+  server: z6.string().optional()
 });
-var ToolCallEndPayloadSchema = z5.looseObject({
-  callId: z5.string().min(1),
+var ToolCallEndPayloadSchema = z6.looseObject({
+  callId: z6.string().min(1),
   output: Json.optional(),
-  error: z5.looseObject({ name: z5.string(), message: z5.string() }).optional(),
-  durationMs: z5.number().int().min(0)
+  error: z6.looseObject({ name: z6.string(), message: z6.string() }).optional(),
+  durationMs: z6.number().int().min(0)
 });
 var PAYMENT_ARTIFACTS = [
   "http-402",
@@ -396,29 +425,30 @@ var PAYMENT_ARTIFACTS = [
   "payment-signature",
   "checkout-url"
 ];
-var PaymentMomentPayloadSchema = z5.looseObject({
-  protocol: z5.string().min(1),
-  payee: z5.string().min(1),
-  amount: z5.looseObject({ value: z5.string().min(1), currency: z5.string().min(1) }),
-  payer: z5.string().optional(),
-  artifact: z5.enum(PAYMENT_ARTIFACTS),
+var PaymentMomentPayloadSchema = z6.looseObject({
+  protocol: z6.string().min(1),
+  payee: z6.string().min(1),
+  amount: z6.looseObject({ value: z6.string().min(1), currency: z6.string().min(1) }),
+  payer: z6.string().optional(),
+  artifact: z6.enum(PAYMENT_ARTIFACTS),
   raw: JsonRecord
 });
-var GatewayDecisionPayloadSchema = z5.looseObject({
-  gateway: z5.string().min(1),
-  call: z5.looseObject({ tool: z5.string().min(1), args: Json.optional() }),
-  decision: z5.enum(["ALLOW", "DENY", "REVIEW", "CHALLENGE"]),
-  reasonCodes: z5.array(z5.string()),
+var GatewayDecisionPayloadSchema = z6.looseObject({
+  gateway: z6.string().min(1),
+  call: z6.looseObject({ tool: z6.string().min(1), args: Json.optional() }),
+  decision: z6.enum(["ALLOW", "DENY", "REVIEW", "CHALLENGE"]),
+  reasonCodes: z6.array(z6.string()),
   /** The gateway's own record of what it decided on — a black box to the platform. */
   record: JsonRecord
 });
-var TransportGapPayloadSchema = z5.looseObject({
-  dropped: z5.number().int().min(1),
-  firstTs: z5.string(),
-  lastTs: z5.string()
+var TransportGapPayloadSchema = z6.looseObject({
+  dropped: z6.number().int().min(1),
+  oversized: z6.number().int().min(0).optional(),
+  firstTs: z6.string(),
+  lastTs: z6.string()
 });
-var PlatformObservationPayloadSchema = z5.strictObject({
-  origin: z5.string().min(1),
+var PlatformObservationPayloadSchema = z6.strictObject({
+  origin: z6.string().min(1),
   params: Json,
   response: Json
 });
@@ -430,10 +460,10 @@ var ANOMALY_TYPES = [
   "clock_skew",
   "source_conflict"
 ];
-var PlatformAnomalyPayloadSchema = z5.looseObject({
-  type: z5.enum(ANOMALY_TYPES),
+var PlatformAnomalyPayloadSchema = z6.looseObject({
+  type: z6.enum(ANOMALY_TYPES),
   source: EvidenceSourceAllSchema,
-  seq: z5.number().int().min(0).nullable(),
+  seq: z6.number().int().min(0).nullable(),
   detail: JsonRecord
 });
 var REGISTRY = {
@@ -472,87 +502,46 @@ var Verdict = class _Verdict {
     const o = typeof other === "string" ? _Verdict.of(other) : other;
     return SEVERITY[o.value] > SEVERITY[this.value] ? o : this;
   }
-  /** Whether a synchronous gate must stop the call (GAP-52). */
-  blocks(onReview) {
-    return this.value === "DENY" || this.value === "REVIEW" && onReview === "abort";
-  }
-  /** What the gate effectively did: DENY when it blocked, else the verdict itself. */
-  effective(onReview) {
-    return this.blocks(onReview) ? "DENY" : this.value;
-  }
 };
 
 export {
-  WIRE_SOURCES,
   ALL_SOURCES,
   EvidenceSourceSchema,
   EvidenceSourceAllSchema,
   SOURCE_ORDER,
   compareBySourceSeq,
+  chainKey,
+  compareByArrival,
+  compareRootFirst,
+  withinHeads,
   compareBySessionSource,
-  WIRE_KINDS,
-  PLATFORM_KINDS,
-  WireEvidenceKindSchema,
-  PlatformEvidenceKindSchema,
-  EvidenceKindSchema,
   Hex64Schema,
-  SigSchema,
+  SESSION_ID_PREFIX,
+  SESSION_ID_CHARS,
   SessionIdSchema,
-  SeqSchema,
   TimestampSchema,
   JsonValueSchema,
   EvidenceEventSchema,
-  isWireKind,
-  isPlatformKind,
+  DecimalStringSchema,
+  AmountSchema,
+  Money,
   INDICATOR_CODES,
   ANNOTATION_CODES,
-  COLLECTOR_CODES,
-  DEFAULT_RULE_CODES,
   REASON_CODE_PATTERN,
-  SelectorSyntaxError,
   parseSelector,
-  formatSelector,
   isSelectorRef,
   parseSelectorRef,
   walkPath,
   SelectorStringSchema,
-  PRIMITIVES,
-  PrimitiveSchema,
-  RuleVerdictSchema,
-  RuleSchema,
   PolicyRulesSchema,
-  AmountSchema,
   DeclaredIntentSchema,
   CreateSessionInputSchema,
-  CreateSessionOutputSchema,
   MAX_BATCH_EVENTS,
   EvidenceBatchInputSchema,
-  EventResultStatusSchema,
-  EventResultSchema,
-  ChainHeadSchema,
-  EvidenceAckSchema,
   PaymentSummarySchema,
   EvaluateInputSchema,
-  DecisionSchema,
-  EvaluateOutputSchema,
   CreatePolicyInputSchema,
-  CreatePolicyOutputSchema,
   ApiErrorSchema,
-  SessionOpenPayloadSchema,
-  SESSION_CLOSE_REASONS,
-  SessionClosePayloadSchema,
-  IntentDeclaredPayloadSchema,
-  LlmCallStartPayloadSchema,
-  LlmCallEndPayloadSchema,
-  ToolCallStartPayloadSchema,
-  ToolCallEndPayloadSchema,
-  PAYMENT_ARTIFACTS,
-  PaymentMomentPayloadSchema,
-  GatewayDecisionPayloadSchema,
-  TransportGapPayloadSchema,
-  PlatformObservationPayloadSchema,
-  ANOMALY_TYPES,
-  PlatformAnomalyPayloadSchema,
   payloadSchemaFor,
   Verdict
 };