@belticlabs/agent-risk-sdk 0.6.0 → 0.7.0

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-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,6 +301,9 @@ 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,

package/dist/{client-CgCjOrRP.d.ts → client-Xn9M58OJ.d.ts}

@@ -1,5 +1,5 @@
-import { a7 as PaymentSummary } from './index-IfY4XCvJ.js';
-import { b as SessionOptions, S as Session, a as Decision } from './session-Dcof4UIn.js';
+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
@@ -22,7 +22,7 @@ import { b as SessionOptions, S as Session, a as Decision } from './session-Dcof
  * is the client's fault and throws.
  */
 
-declare const SDK_VERSION = "0.6.0";
+declare const SDK_VERSION = "0.7.0";
 interface BelticOptions {
     apiKey: string;
     baseUrl: string;
@@ -32,6 +32,7 @@ interface BelticOptions {
 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
@@ -42,20 +43,25 @@ declare class Beltic {
     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`.
+     * 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(key: string, opts?: SessionOptions): 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 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).
+     * 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): Promise<Decision>;
-    /** Send everything buffered now and wait for that attempt. */
+    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`. */

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

@@ -13,7 +13,6 @@ import { z } from 'zod';
  * GAP-08 names the internal kinds it carries.
  */
 
-declare const WIRE_SOURCES: readonly ["AGENT_TRACE", "INTERNAL_NETWORK"];
 declare const ALL_SOURCES: readonly ["AGENT_TRACE", "INTERNAL_NETWORK", "PLATFORM"];
 declare const EvidenceSourceSchema: z.ZodEnum<{
     AGENT_TRACE: "AGENT_TRACE";
@@ -36,22 +35,50 @@ declare function compareBySourceSeq(a: {
     source: EvidenceSourceAll;
     seq: number;
 }): number;
-/** Commitments across sessions: by sessionId, then source. */
-declare function compareBySessionSource(a: {
+/** One chain's key wherever heads are reported: `sessionId:source`. */
+declare function chainKey(sessionId: string, source: EvidenceSourceAll): string;
+/**
+ * The order a conversation is read in: when it happened, when the platform
+ * saw it, then by chain and seq — the one order that interleaves the
+ * chains of every session of a conversation (GAP-84).
+ */
+declare function compareByArrival(a: {
+    ts: string;
+    receivedAt: string;
     sessionId: string;
     source: EvidenceSourceAll;
+    seq: number;
 }, b: {
+    ts: string;
+    receivedAt: string;
     sessionId: string;
     source: EvidenceSourceAll;
+    seq: number;
 }): number;
+/** The root of a conversation before its members; a store then orders the members its own way. */
+declare function compareRootFirst(conversationId: string): (a: {
+    id: string;
+}, b: {
+    id: string;
+}) => number;
 /**
- * Kinds are protocol moments, not protocol artifacts. `transport.gap` is
- * not in the RFC: it is how an SDK whose buffer overflowed says so without
- * leaving a hole in the chain (GAP-38).
+ * Whether a row is inside the heads a decision pinned (replay): its chain
+ * is among them and its seq is at or below that head. A chain the decision
+ * never saw is outside.
  */
-declare const WIRE_KINDS: readonly ["session.open", "session.close", "intent.declared", "llm_call.start", "llm_call.end", "tool_call.start", "tool_call.end", "payment.requested", "payment.presented", "gateway.decision", "transport.gap"];
-/** Written only by the platform itself (`observe()`, Collector anomalies). GAP-08. */
-declare const PLATFORM_KINDS: readonly ["platform.observation", "platform.anomaly"];
+declare function withinHeads(heads: Readonly<Record<string, number>>): (e: {
+    sessionId: string;
+    source: EvidenceSourceAll;
+    seq: number;
+}) => boolean;
+/** Commitments across sessions: by sessionId, then source. */
+declare function compareBySessionSource(a: {
+    sessionId: string;
+    source: EvidenceSourceAll;
+}, b: {
+    sessionId: string;
+    source: EvidenceSourceAll;
+}): number;
 declare const WireEvidenceKindSchema: z.ZodEnum<{
     "session.open": "session.open";
     "session.close": "session.close";
@@ -93,8 +120,15 @@ type Hex64 = z.infer<typeof Hex64Schema>;
 /** `ed25519:` + base64url (no padding) of a 64-byte signature (GAP-03). */
 declare const SigSchema: z.ZodString;
 type Sig = z.infer<typeof SigSchema>;
-declare const SessionIdSchema: z.ZodUUID;
-declare const SeqSchema: z.ZodNumber;
+/**
+ * The public session id: what every event, ack, evaluate and binding
+ * names, and the only form the wire accepts. Minted by the platform
+ * (`sess_` + 22 base62 chars, 128 bits); the uuid primary key never
+ * leaves persistence (GAP-86).
+ */
+declare const SESSION_ID_PREFIX = "sess_";
+declare const SESSION_ID_CHARS = 22;
+declare const SessionIdSchema: z.ZodString;
 declare const TimestampSchema: z.ZodISODateTime;
 /** JSON value that survives RFC 8785 canonicalization unchanged. */
 declare const JsonValueSchema: z.ZodType<JsonValue>;
@@ -105,7 +139,7 @@ type JsonObject = {
     [key: string]: JsonValue;
 };
 declare const EvidenceEventSchema: z.ZodObject<{
-    sessionId: z.ZodUUID;
+    sessionId: z.ZodString;
     source: z.ZodEnum<{
         AGENT_TRACE: "AGENT_TRACE";
         INTERNAL_NETWORK: "INTERNAL_NETWORK";
@@ -154,14 +188,7 @@ interface ChainHead {
     seq: number;
     digest: Hex64;
 }
-declare function isWireKind(kind: string): kind is WireEvidenceKind;
-declare function isPlatformKind(kind: string): kind is PlatformEvidenceKind;
 
-declare const AmountSchema: z.ZodObject<{
-    value: z.ZodString;
-    currency: z.ZodString;
-}, z.core.$strict>;
-type Amount = z.infer<typeof AmountSchema>;
 declare const DeclaredIntentSchema: z.ZodObject<{
     mandate: z.ZodString;
     maxAmount: z.ZodOptional<z.ZodObject<{
@@ -190,94 +217,41 @@ declare const CreateSessionInputSchema: z.ZodObject<{
         merchantAllowlist: z.ZodOptional<z.ZodArray<z.ZodString>>;
         validUntil: z.ZodISODateTime;
     }, z.core.$strict>>;
+    resume: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 type CreateSessionInput = z.infer<typeof CreateSessionInputSchema>;
-declare const CreateSessionOutputSchema: z.ZodObject<{
-    sessionId: z.ZodUUID;
-    expiresAt: z.ZodISODateTime;
-}, z.core.$strict>;
-type CreateSessionOutput = z.infer<typeof CreateSessionOutputSchema>;
+/** The conversation's last prompt as a base for deltas: the call it was recorded on, one digest per message (GAP-89). */
+interface PromptBase {
+    prior: string;
+    digests: Hex64[];
+}
+interface CreateSessionOutput {
+    /** This session's public id — the `sessionId` of its events and of the x402 binding (GAP-86). */
+    sessionId: string;
+    /** The conversation this session belongs to: the root's public id, stable across resumes (GAP-84). */
+    conversationId: string;
+    expiresAt: string;
+    /** On a resume: the base the next `llm_call.start` may ship a delta against (GAP-89). */
+    prompt?: PromptBase;
+}
 declare const MAX_BATCH_EVENTS = 500;
-declare const EvidenceBatchInputSchema: z.ZodArray<z.ZodObject<{
-    sessionId: z.ZodUUID;
-    source: z.ZodEnum<{
-        AGENT_TRACE: "AGENT_TRACE";
-        INTERNAL_NETWORK: "INTERNAL_NETWORK";
-    }>;
-    seq: z.ZodNumber;
-    ts: z.ZodISODateTime;
-    kind: z.ZodEnum<{
-        "session.open": "session.open";
-        "session.close": "session.close";
-        "intent.declared": "intent.declared";
-        "llm_call.start": "llm_call.start";
-        "llm_call.end": "llm_call.end";
-        "tool_call.start": "tool_call.start";
-        "tool_call.end": "tool_call.end";
-        "payment.requested": "payment.requested";
-        "payment.presented": "payment.presented";
-        "gateway.decision": "gateway.decision";
-        "transport.gap": "transport.gap";
-    }>;
-    payload: z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
-    prevHash: z.ZodString;
-    sig: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>>;
-type EvidenceBatchInput = z.infer<typeof EvidenceBatchInputSchema>;
-declare const EventResultStatusSchema: z.ZodEnum<{
-    ok: "ok";
-    duplicate: "duplicate";
-    fork: "fork";
-    rejected: "rejected";
-}>;
-type EventResultStatus = z.infer<typeof EventResultStatusSchema>;
+/** The batch as the route takes it; each event is judged on its own by the Collector, with its own result (GAP-17). */
+declare const EvidenceBatchInputSchema: z.ZodArray<z.ZodUnknown>;
 /** Per-event outcome of a batch (GAP-17). `seq` is null when the event could not be parsed. */
-declare const EventResultSchema: z.ZodObject<{
-    index: z.ZodNumber;
-    sessionId: z.ZodNullable<z.ZodUUID>;
-    source: z.ZodNullable<z.ZodEnum<{
-        AGENT_TRACE: "AGENT_TRACE";
-        INTERNAL_NETWORK: "INTERNAL_NETWORK";
-    }>>;
-    seq: z.ZodNullable<z.ZodNumber>;
-    status: z.ZodEnum<{
-        ok: "ok";
-        duplicate: "duplicate";
-        fork: "fork";
-        rejected: "rejected";
-    }>;
-    code: z.ZodOptional<z.ZodString>;
-    eventDigest: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-type EventResult = z.infer<typeof EventResultSchema>;
-declare const ChainHeadSchema: z.ZodObject<{
-    seq: z.ZodNumber;
-    digest: z.ZodString;
-}, z.core.$strict>;
-declare const EvidenceAckSchema: z.ZodObject<{
-    results: z.ZodArray<z.ZodObject<{
-        index: z.ZodNumber;
-        sessionId: z.ZodNullable<z.ZodUUID>;
-        source: z.ZodNullable<z.ZodEnum<{
-            AGENT_TRACE: "AGENT_TRACE";
-            INTERNAL_NETWORK: "INTERNAL_NETWORK";
-        }>>;
-        seq: z.ZodNullable<z.ZodNumber>;
-        status: z.ZodEnum<{
-            ok: "ok";
-            duplicate: "duplicate";
-            fork: "fork";
-            rejected: "rejected";
-        }>;
-        code: z.ZodOptional<z.ZodString>;
-        eventDigest: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
-    heads: z.ZodRecord<z.ZodString, z.ZodObject<{
-        seq: z.ZodNumber;
-        digest: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-type EvidenceAck = z.infer<typeof EvidenceAckSchema>;
+interface EventResult {
+    index: number;
+    sessionId: string | null;
+    source: EvidenceSource | null;
+    seq: number | null;
+    status: 'ok' | 'duplicate' | 'fork' | 'rejected';
+    code?: string;
+    eventDigest?: Hex64;
+}
+interface EvidenceAck {
+    results: EventResult[];
+    /** Head of every chain touched by the batch, after the batch. Keyed `sessionId:source`. */
+    heads: Record<string, ChainHead>;
+}
 declare const PaymentSummarySchema: z.ZodObject<{
     protocol: z.ZodString;
     payee: z.ZodString;
@@ -289,7 +263,7 @@ declare const PaymentSummarySchema: z.ZodObject<{
 }, z.core.$strict>;
 type PaymentSummary = z.infer<typeof PaymentSummarySchema>;
 declare const EvaluateInputSchema: z.ZodObject<{
-    sessionId: z.ZodUUID;
+    sessionId: z.ZodString;
     payment: z.ZodObject<{
         protocol: z.ZodString;
         payee: z.ZodString;
@@ -299,25 +273,17 @@ declare const EvaluateInputSchema: z.ZodObject<{
         }, z.core.$strict>;
         payer: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
+    callId: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 type EvaluateInput = z.infer<typeof EvaluateInputSchema>;
-declare const DecisionSchema: z.ZodEnum<{
-    DENY: "DENY";
-    REVIEW: "REVIEW";
-    ALLOW: "ALLOW";
-}>;
-type Decision = z.infer<typeof DecisionSchema>;
-declare const EvaluateOutputSchema: z.ZodObject<{
-    decision: z.ZodEnum<{
-        DENY: "DENY";
-        REVIEW: "REVIEW";
-        ALLOW: "ALLOW";
-    }>;
-    reasonCodes: z.ZodArray<z.ZodString>;
-    sessionId: z.ZodUUID;
-    decisionId: z.ZodUUID;
-}, z.core.$strict>;
-type EvaluateOutput = z.infer<typeof EvaluateOutputSchema>;
+type Decision = 'ALLOW' | 'DENY' | 'REVIEW';
+interface EvaluateOutput {
+    decision: Decision;
+    reasonCodes: string[];
+    sessionId: string;
+    /** Additive (GAP-21). */
+    decisionId: string;
+}
 /** Non-RFC admin surface (GAP-53). */
 declare const CreatePolicyInputSchema: z.ZodObject<{
     rules: z.ZodObject<{
@@ -343,20 +309,13 @@ declare const CreatePolicyInputSchema: z.ZodObject<{
             }>>;
             code: z.ZodString;
         }, z.core.$strict>>;
-        scoreThresholds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
     }, z.core.$strict>;
 }, z.core.$strict>;
-type CreatePolicyInput = z.infer<typeof CreatePolicyInputSchema>;
-declare const CreatePolicyOutputSchema: z.ZodObject<{
-    policyId: z.ZodUUID;
-    version: z.ZodNumber;
-    status: z.ZodEnum<{
-        ACTIVE: "ACTIVE";
-        SUPERSEDED: "SUPERSEDED";
-        DRAFT: "DRAFT";
-    }>;
-}, z.core.$strict>;
-type CreatePolicyOutput = z.infer<typeof CreatePolicyOutputSchema>;
+interface CreatePolicyOutput {
+    policyId: string;
+    version: number;
+    status: 'ACTIVE' | 'SUPERSEDED' | 'DRAFT';
+}
 /** Error envelope (GAP-20). */
 declare const ApiErrorSchema: z.ZodObject<{
     error: z.ZodObject<{
@@ -377,7 +336,6 @@ declare const SessionOpenPayloadSchema: z.ZodObject<{
     }, z.core.$loose>;
     attestations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
 }, z.core.$loose>;
-declare const SESSION_CLOSE_REASONS: readonly ["completed", "settled", "aborted", "expired"];
 declare const SessionClosePayloadSchema: z.ZodObject<{
     reason: z.ZodEnum<{
         completed: "completed";
@@ -396,11 +354,38 @@ declare const IntentDeclaredPayloadSchema: z.ZodObject<{
     merchantAllowlist: z.ZodOptional<z.ZodArray<z.ZodString>>;
     validUntil: z.ZodISODateTime;
 }, z.core.$loose>;
+/**
+ * A prompt as the difference from an earlier call's (GAP-89): `prior` is
+ * the `callId` of the `llm_call.start` whose *unfolded* prompt this one
+ * extends, `shared` how many of its leading messages are equal (JCS +
+ * SHA-256 per message), `messages` the rest.
+ */
+declare const PromptDeltaSchema: z.ZodObject<{
+    prior: z.ZodString;
+    shared: z.ZodNumber;
+    messages: z.ZodArray<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+}, z.core.$strict>;
+/** The provider-level call options (GAP-57); the prompt whole, or as a delta, never both. */
+declare const LlmCallParamsSchema: z.ZodObject<{
+    prompt: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+    promptDelta: z.ZodOptional<z.ZodObject<{
+        prior: z.ZodString;
+        shared: z.ZodNumber;
+        messages: z.ZodArray<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+    }, z.core.$strict>>;
+}, z.core.$loose>;
 declare const LlmCallStartPayloadSchema: z.ZodObject<{
     callId: z.ZodString;
     provider: z.ZodString;
     modelId: z.ZodString;
-    params: z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+    params: z.ZodObject<{
+        prompt: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+        promptDelta: z.ZodOptional<z.ZodObject<{
+            prior: z.ZodString;
+            shared: z.ZodNumber;
+            messages: z.ZodArray<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+        }, z.core.$strict>>;
+    }, z.core.$loose>;
 }, z.core.$loose>;
 declare const LlmCallEndPayloadSchema: z.ZodObject<{
     callId: z.ZodString;
@@ -432,7 +417,6 @@ declare const ToolCallEndPayloadSchema: z.ZodObject<{
     }, z.core.$loose>>;
     durationMs: z.ZodNumber;
 }, z.core.$loose>;
-declare const PAYMENT_ARTIFACTS: readonly ["http-402", "mrtr-input-required", "payment-signature", "checkout-url"];
 /**
  * A payment moment, normalized across protocols so the engine can compare
  * the two sides of the same purchase (`EVIDENCE_MISMATCH`, GAP-50). `raw` is
@@ -470,9 +454,14 @@ declare const GatewayDecisionPayloadSchema: z.ZodObject<{
     reasonCodes: z.ZodArray<z.ZodString>;
     record: z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
 }, z.core.$loose>;
-/** Emitted by the SDK after its transport buffer overflowed (GAP-38). */
+/**
+ * Emitted by the SDK after it dropped events pre-sequencing (GAP-38): for
+ * lack of room in its buffer, or — `oversized` of them — because the
+ * platform would refuse them as too large (GAP-87).
+ */
 declare const TransportGapPayloadSchema: z.ZodObject<{
     dropped: z.ZodNumber;
+    oversized: z.ZodOptional<z.ZodNumber>;
     firstTs: z.ZodString;
     lastTs: z.ZodString;
 }, z.core.$loose>;
@@ -482,7 +471,6 @@ declare const PlatformObservationPayloadSchema: z.ZodObject<{
     params: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
     response: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
 }, z.core.$strict>;
-declare const ANOMALY_TYPES: readonly ["fork", "seq_gap", "prev_hash_mismatch", "bad_sig", "clock_skew", "source_conflict"];
 declare const PlatformAnomalyPayloadSchema: z.ZodObject<{
     type: z.ZodEnum<{
         fork: "fork";
@@ -503,6 +491,8 @@ declare const PlatformAnomalyPayloadSchema: z.ZodObject<{
 type SessionOpenPayload = z.infer<typeof SessionOpenPayloadSchema>;
 type SessionClosePayload = z.infer<typeof SessionClosePayloadSchema>;
 type IntentDeclaredPayload = z.infer<typeof IntentDeclaredPayloadSchema>;
+type PromptDelta = z.infer<typeof PromptDeltaSchema>;
+type LlmCallParams = z.infer<typeof LlmCallParamsSchema>;
 type LlmCallStartPayload = z.infer<typeof LlmCallStartPayloadSchema>;
 type LlmCallEndPayload = z.infer<typeof LlmCallEndPayloadSchema>;
 type ToolCallStartPayload = z.infer<typeof ToolCallStartPayloadSchema>;
@@ -529,4 +519,4 @@ interface PayloadByKind {
     'platform.anomaly': PlatformAnomalyPayload;
 }
 
-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 };
+export { type Sig as $, ALL_SOURCES as A, type LlmCallParams as B, type ChainHead as C, type Decision as D, type EvidenceSourceAll as E, type LlmCallStartPayload as F, type GatewayDecisionPayload as G, type Hex64 as H, type IntentDeclaredPayload as I, type JsonValue as J, type PaymentMomentPayload as K, type LlmCallEndPayload as L, MAX_BATCH_EVENTS as M, type PaymentSummary as N, PaymentSummarySchema as O, type PayloadByKind as P, type PlatformAnomalyPayload as Q, type PlatformEvidenceKind as R, type PlatformObservationPayload as S, type PromptBase as T, type PromptDelta as U, SESSION_ID_CHARS as V, SESSION_ID_PREFIX as W, SOURCE_ORDER as X, type SessionClosePayload as Y, SessionIdSchema as Z, type SessionOpenPayload as _, type ApiError as a, TimestampSchema as a0, type ToolCallEndPayload as a1, type ToolCallStartPayload as a2, type TransportGapPayload as a3, type WireEvidenceKind as a4, chainKey as a5, compareByArrival as a6, compareBySessionSource as a7, compareBySourceSeq as a8, compareRootFirst as a9, payloadSchemaFor as aa, withinHeads as ab, ApiErrorSchema as b, CreatePolicyInputSchema as c, type CreatePolicyOutput as d, type CreateSessionInput as e, CreateSessionInputSchema as f, type CreateSessionOutput as g, type DeclaredIntent as h, DeclaredIntentSchema as i, type DigestedEnvelope as j, type EvaluateInput as k, EvaluateInputSchema as l, type EvaluateOutput as m, type EventResult as n, type EvidenceAck as o, EvidenceBatchInputSchema as p, type EvidenceEnvelope as q, type EvidenceEvent as r, EvidenceEventSchema as s, type EvidenceKind as t, type EvidenceSource as u, EvidenceSourceAllSchema as v, EvidenceSourceSchema as w, Hex64Schema as x, type JsonObject as y, JsonValueSchema as z };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-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';
+export { B as Beltic, a as BelticOptions, S as SDK_VERSION } from './client-Xn9M58OJ.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-DAN29XoB.js';
+import './index-DAVKGJs5.js';
 import 'zod';
 
 /**