@belticlabs/agent-risk-sdk 0.6.0 → 0.7.0

package/dist/protocol/index.d.ts

@@ -1,8 +1,49 @@
-import { J as JsonValue, E as EvidenceSourceAll, D as Decision } from '../index-IfY4XCvJ.js';
-export { A as ALL_SOURCES, a as ANOMALY_TYPES, b as Amount, c as AmountSchema, d as ApiError, e as ApiErrorSchema, C as ChainHead, f as ChainHeadSchema, g as CreatePolicyInput, h as CreatePolicyInputSchema, i as CreatePolicyOutput, j as CreatePolicyOutputSchema, k as CreateSessionInput, l as CreateSessionInputSchema, m as CreateSessionOutput, n as CreateSessionOutputSchema, o as DecisionSchema, p as DeclaredIntent, q as DeclaredIntentSchema, r as DigestedEnvelope, s as EvaluateInput, t as EvaluateInputSchema, u as EvaluateOutput, v as EvaluateOutputSchema, w as EventResult, x as EventResultSchema, y as EventResultStatus, z as EventResultStatusSchema, B as EvidenceAck, F as EvidenceAckSchema, G as EvidenceBatchInput, H as EvidenceBatchInputSchema, I as EvidenceEnvelope, K as EvidenceEvent, L as EvidenceEventSchema, M as EvidenceKind, N as EvidenceKindSchema, O as EvidenceSource, P as EvidenceSourceAllSchema, Q as EvidenceSourceSchema, R as GatewayDecisionPayload, S as GatewayDecisionPayloadSchema, T as Hex64, U as Hex64Schema, V as IntentDeclaredPayload, W as IntentDeclaredPayloadSchema, X as JsonObject, Y as JsonValueSchema, Z as LlmCallEndPayload, _ as LlmCallEndPayloadSchema, $ as LlmCallStartPayload, a0 as LlmCallStartPayloadSchema, a1 as MAX_BATCH_EVENTS, a2 as PAYMENT_ARTIFACTS, a3 as PLATFORM_KINDS, a4 as PayloadByKind, a5 as PaymentMomentPayload, a6 as PaymentMomentPayloadSchema, a7 as PaymentSummary, a8 as PaymentSummarySchema, a9 as PlatformAnomalyPayload, aa as PlatformAnomalyPayloadSchema, ab as PlatformEvidenceKind, ac as PlatformEvidenceKindSchema, ad as PlatformObservationPayload, ae as PlatformObservationPayloadSchema, af as SESSION_CLOSE_REASONS, ag as SOURCE_ORDER, ah as SeqSchema, ai as SessionClosePayload, aj as SessionClosePayloadSchema, ak as SessionIdSchema, al as SessionOpenPayload, am as SessionOpenPayloadSchema, an as Sig, ao as SigSchema, ap as TimestampSchema, aq as ToolCallEndPayload, ar as ToolCallEndPayloadSchema, as as ToolCallStartPayload, at as ToolCallStartPayloadSchema, au as TransportGapPayload, av as TransportGapPayloadSchema, aw as WIRE_KINDS, ax as WIRE_SOURCES, ay as WireEvidenceKind, az as WireEvidenceKindSchema, aA as compareBySessionSource, aB as compareBySourceSeq, aC as isPlatformKind, aD as isWireKind, aE as payloadSchemaFor } from '../index-IfY4XCvJ.js';
+import { J as JsonValue, E as EvidenceSourceAll, D as Decision } from '../index-DAVKGJs5.js';
+export { A as ALL_SOURCES, a as ApiError, b as ApiErrorSchema, C as ChainHead, c as CreatePolicyInputSchema, d as CreatePolicyOutput, e as CreateSessionInput, f as CreateSessionInputSchema, g as CreateSessionOutput, h as DeclaredIntent, i as DeclaredIntentSchema, j as DigestedEnvelope, k as EvaluateInput, l as EvaluateInputSchema, m as EvaluateOutput, n as EventResult, o as EvidenceAck, p as EvidenceBatchInputSchema, q as EvidenceEnvelope, r as EvidenceEvent, s as EvidenceEventSchema, t as EvidenceKind, u as EvidenceSource, v as EvidenceSourceAllSchema, w as EvidenceSourceSchema, G as GatewayDecisionPayload, H as Hex64, x as Hex64Schema, I as IntentDeclaredPayload, y as JsonObject, z as JsonValueSchema, L as LlmCallEndPayload, B as LlmCallParams, F as LlmCallStartPayload, M as MAX_BATCH_EVENTS, P as PayloadByKind, K as PaymentMomentPayload, N as PaymentSummary, O as PaymentSummarySchema, Q as PlatformAnomalyPayload, R as PlatformEvidenceKind, S as PlatformObservationPayload, T as PromptBase, U as PromptDelta, V as SESSION_ID_CHARS, W as SESSION_ID_PREFIX, X as SOURCE_ORDER, Y as SessionClosePayload, Z as SessionIdSchema, _ as SessionOpenPayload, $ as Sig, a0 as TimestampSchema, a1 as ToolCallEndPayload, a2 as ToolCallStartPayload, a3 as TransportGapPayload, a4 as WireEvidenceKind, a5 as chainKey, a6 as compareByArrival, a7 as compareBySessionSource, a8 as compareBySourceSeq, a9 as compareRootFirst, aa as payloadSchemaFor, ab as withinHeads } from '../index-DAVKGJs5.js';
 import { z } from 'zod';
 
-declare const PRIMITIVES: readonly ["THRESHOLD", "MEMBERSHIP", "MATCH", "PRESENCE", "FRESHNESS"];
+/**
+ * Amounts are decimal strings, never floats (Fraud Engine RFC › API:
+ * `amount: { value: string; currency: string }`). One grammar for the wire
+ * and the engine, and one value object that compares and adds over scaled
+ * BigInts, so 0.1 + 0.2 is 0.3 and an atomic x402 amount of 18 digits
+ * keeps its precision. A currency mismatch is never coerced away (GAP-49):
+ * two amounts are comparable only when they name the same currency or one
+ * names none (a bare bound in a rule).
+ */
+
+declare const DecimalStringSchema: z.ZodString;
+type DecimalString = z.infer<typeof DecimalStringSchema>;
+declare const AmountSchema: z.ZodObject<{
+    value: z.ZodString;
+    currency: z.ZodString;
+}, z.core.$strict>;
+type Amount = z.infer<typeof AmountSchema>;
+declare class Money {
+    readonly value: DecimalString;
+    readonly currency: string | null;
+    private constructor();
+    static of(amount: Amount): Money;
+    /** A decimal with no currency: a bound in a rule, a running total. */
+    static bare(value: string): Money;
+    /** An x402 amount: atomic units of `asset` on `network`, its currency `<network>/<asset>` (GAP-49). */
+    static x402(network: string, asset: string, atomic: string | bigint): Money;
+    static x402Currency(network: string, asset: string): string;
+    /** Anything a selector or a rule param may resolve to; null when it is not an amount. */
+    static parse(v: unknown): Money | null;
+    comparable(other: Money): boolean;
+    compareTo(other: Money): -1 | 0 | 1;
+    exceeds(other: Money): boolean;
+    plus(other: Money): Money;
+    isZero(): boolean;
+    /** Numeric view for ratios; precision loss is acceptable for a ratio. */
+    toNumber(): number;
+    /** this / other, or null when `other` is zero. */
+    ratioTo(other: Money): number | null;
+    toAmount(): Amount;
+    private static scaled;
+}
+
 declare const PrimitiveSchema: z.ZodEnum<{
     THRESHOLD: "THRESHOLD";
     MEMBERSHIP: "MEMBERSHIP";
@@ -66,18 +107,17 @@ declare const PolicyRulesSchema: z.ZodObject<{
         }>>;
         code: z.ZodString;
     }, z.core.$strict>>;
-    scoreThresholds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
 }, z.core.$strict>;
 type PolicyRules = z.infer<typeof PolicyRulesSchema>;
 
 /**
  * Reason codes are the only thing that crosses the verdict boundary besides
  * the verdict itself (Fraud Engine RFC › API: "the seller receives a verdict
- * and reasons — never the record"). Three families, kept separate so the
- * type system knows which layer may emit which.
+ * and reasons — never the record"). The platform's own codes are named here;
+ * an owner's rule codes are content, checked only against the pattern (GAP-44).
  */
 /** Static platform policy — may DENY alone (Fraud Engine RFC › Fraud indicators). */
-declare const INDICATOR_CODES: readonly ["CHAIN_BROKEN", "EVIDENCE_MISMATCH", "CREDENTIAL_REVOKED", "SESSION_INVALID", "PRINCIPAL_FLAGGED"];
+declare const INDICATOR_CODES: readonly ["CHAIN_BROKEN", "EVIDENCE_MISMATCH", "SESSION_INVALID"];
 type IndicatorCode = (typeof INDICATOR_CODES)[number];
 /**
  * Annotations describe the floor the decision was made on. They never change
@@ -85,14 +125,8 @@ type IndicatorCode = (typeof INDICATOR_CODES)[number];
  * the owner's rules, not a denial (GAP-43).
  */
 declare const ANNOTATION_CODES: readonly ["NO_AGENT_TRACE", "NO_POLICY"];
-type AnnotationCode = (typeof ANNOTATION_CODES)[number];
 /** Why the Collector refused or downgraded an event (per-event ack, GAP-17). */
-declare const COLLECTOR_CODES: readonly ["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"];
-type CollectorCode = (typeof COLLECTOR_CODES)[number];
-/** Codes the platform default policy uses; owners may define their own (GAP-44). */
-declare const DEFAULT_RULE_CODES: readonly ["CAP_EXCEEDED", "PAYEE_NOT_ALLOWED", "NO_INTENT", "INTENT_EXPIRED"];
-type DefaultRuleCode = (typeof DEFAULT_RULE_CODES)[number];
-type ReasonCode = IndicatorCode | AnnotationCode | DefaultRuleCode | (string & {});
+type CollectorCode = 'SCHEMA_INVALID' | 'SESSION_UNKNOWN' | 'SESSION_CLOSED' | 'SESSION_EXPIRED' | 'SOURCE_FORBIDDEN' | 'SEQ_GAP' | 'PREV_HASH_MISMATCH' | 'SIG_MISSING' | 'SIG_INVALID' | 'PAYLOAD_INVALID' | 'EVENT_TOO_LARGE';
 declare const REASON_CODE_PATTERN: RegExp;
 
 /**
@@ -140,14 +174,7 @@ type Selector = {
     all: boolean;
     path: PathSegment[];
 };
-declare class SelectorSyntaxError extends Error {
-    readonly input: string;
-    readonly at: number;
-    readonly code = "SELECTOR_SYNTAX";
-    constructor(input: string, at: number, detail: string);
-}
 declare function parseSelector(input: string): Selector;
-declare function formatSelector(sel: Selector): string;
 declare function isSelectorRef(value: unknown): value is `@${string}`;
 declare function parseSelectorRef(ref: string): Selector;
 /** Walk a `path` over a value; `undefined` when any step is missing. */
@@ -156,12 +183,10 @@ declare const SelectorStringSchema: z.ZodString;
 
 /**
  * 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.
+ * Layers combine by severity (GAP-45): the decision is the most severe
+ * verdict any layer produced.
  */
 
-type OnReview = 'abort' | 'allow';
 declare class Verdict {
     readonly value: Decision;
     private constructor();
@@ -171,10 +196,6 @@ declare class 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 { ANNOTATION_CODES, type AnnotationCode, COLLECTOR_CODES, type CollectorCode, DEFAULT_RULE_CODES, Decision, type DefaultRuleCode, EvidenceSourceAll, INDICATOR_CODES, type IndicatorCode, JsonValue, type OnReview, PRIMITIVES, type PathSegment, type PolicyRules, PolicyRulesSchema, type Primitive, PrimitiveSchema, REASON_CODE_PATTERN, type ReasonCode, type Rule, RuleSchema, type RuleVerdict, RuleVerdictSchema, type Selector, SelectorStringSchema, SelectorSyntaxError, Verdict, formatSelector, isSelectorRef, parseSelector, parseSelectorRef, walkPath };
+export { ANNOTATION_CODES, type Amount, AmountSchema, type CollectorCode, type DecimalString, DecimalStringSchema, Decision, EvidenceSourceAll, INDICATOR_CODES, type IndicatorCode, JsonValue, Money, type PathSegment, type PolicyRules, PolicyRulesSchema, type Primitive, REASON_CODE_PATTERN, type Rule, type RuleVerdict, type Selector, SelectorStringSchema, Verdict, isSelectorRef, parseSelector, parseSelectorRef, walkPath };