@belticlabs/agent-risk-sdk 0.1.0 → 0.2.0

package/dist/index-Bjs3BPPU.d.ts

@@ -0,0 +1,547 @@
+import { z } from 'zod';
+
+/**
+ * Wire contract — `EvidenceEvent` (Fraud SDK RFC › Wire contract).
+ *
+ * Evidence is the agent log shipped whole: full payloads, not summaries.
+ * Each event commits to its predecessor (`prevHash`), so a session's
+ * evidence is a per-(sessionId, source) chain and the chain head
+ * fingerprints all of it.
+ *
+ * `source` is provenance, not artifact type. `PLATFORM` exists only inside
+ * the platform (detector observations) and never travels this wire —
+ * 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";
+    INTERNAL_NETWORK: "INTERNAL_NETWORK";
+}>;
+declare const EvidenceSourceAllSchema: z.ZodEnum<{
+    AGENT_TRACE: "AGENT_TRACE";
+    INTERNAL_NETWORK: "INTERNAL_NETWORK";
+    PLATFORM: "PLATFORM";
+}>;
+type EvidenceSource = z.infer<typeof EvidenceSourceSchema>;
+type EvidenceSourceAll = z.infer<typeof EvidenceSourceAllSchema>;
+/** Order used when a session root is built over its source roots (GAP-29). */
+declare const SOURCE_ORDER: Record<EvidenceSourceAll, number>;
+/** The one order evidence is ever listed in: by source (SOURCE_ORDER), then seq. */
+declare function compareBySourceSeq(a: {
+    source: EvidenceSourceAll;
+    seq: number;
+}, b: {
+    source: EvidenceSourceAll;
+    seq: number;
+}): number;
+/** Commitments across sessions: by sessionId, then source. */
+declare function compareBySessionSource(a: {
+    sessionId: string;
+    source: EvidenceSourceAll;
+}, b: {
+    sessionId: string;
+    source: EvidenceSourceAll;
+}): 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).
+ */
+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 const WireEvidenceKindSchema: 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";
+}>;
+declare const PlatformEvidenceKindSchema: z.ZodEnum<{
+    "platform.observation": "platform.observation";
+    "platform.anomaly": "platform.anomaly";
+}>;
+declare const EvidenceKindSchema: 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";
+    "platform.observation": "platform.observation";
+    "platform.anomaly": "platform.anomaly";
+}>;
+type WireEvidenceKind = z.infer<typeof WireEvidenceKindSchema>;
+type PlatformEvidenceKind = z.infer<typeof PlatformEvidenceKindSchema>;
+type EvidenceKind = z.infer<typeof EvidenceKindSchema>;
+/** 32-byte digest, exactly 64 lowercase hex chars (GAP-03). Uppercase is rejected on purpose. */
+declare const Hex64Schema: z.ZodString;
+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;
+declare const TimestampSchema: z.ZodISODateTime;
+/** JSON value that survives RFC 8785 canonicalization unchanged. */
+declare const JsonValueSchema: z.ZodType<JsonValue>;
+type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+type JsonObject = {
+    [key: string]: JsonValue;
+};
+declare const EvidenceEventSchema: 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 EvidenceEvent = z.infer<typeof EvidenceEventSchema>;
+/**
+ * What the platform keeps of an event once the payload body has been moved
+ * to the content-addressed store: the envelope, with `payload` replaced by
+ * its digest. This is the shape `eventDigest` is computed over (GAP-02),
+ * for every source including PLATFORM.
+ */
+interface EvidenceEnvelope {
+    sessionId: string;
+    source: EvidenceSourceAll;
+    seq: number;
+    ts: string;
+    kind: EvidenceKind;
+    payloadDigest: Hex64;
+    prevHash: Hex64;
+    sig?: Sig | undefined;
+}
+/** The fields of the envelope that `eventDigest` commits to, in the RFC's order (GAP-02). */
+type DigestedEnvelope = Pick<EvidenceEnvelope, 'sessionId' | 'source' | 'seq' | 'ts' | 'kind' | 'prevHash'> & {
+    payload: Hex64;
+};
+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<{
+        value: z.ZodString;
+        currency: z.ZodString;
+    }, z.core.$strict>>;
+    merchantAllowlist: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    validUntil: z.ZodISODateTime;
+}, z.core.$strict>;
+type DeclaredIntent = z.infer<typeof DeclaredIntentSchema>;
+declare const CreateSessionInputSchema: z.ZodObject<{
+    source: z.ZodEnum<{
+        AGENT_TRACE: "AGENT_TRACE";
+        INTERNAL_NETWORK: "INTERNAL_NETWORK";
+    }>;
+    agent: z.ZodOptional<z.ZodObject<{
+        did: z.ZodString;
+        credential: z.ZodString;
+    }, z.core.$strict>>;
+    intent: z.ZodOptional<z.ZodObject<{
+        mandate: z.ZodString;
+        maxAmount: z.ZodOptional<z.ZodObject<{
+            value: z.ZodString;
+            currency: z.ZodString;
+        }, z.core.$strict>>;
+        merchantAllowlist: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        validUntil: z.ZodISODateTime;
+    }, z.core.$strict>>;
+}, 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>;
+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>;
+/** 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>;
+declare const PaymentSummarySchema: z.ZodObject<{
+    protocol: z.ZodString;
+    payee: z.ZodString;
+    amount: z.ZodObject<{
+        value: z.ZodString;
+        currency: z.ZodString;
+    }, z.core.$strict>;
+    payer: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type PaymentSummary = z.infer<typeof PaymentSummarySchema>;
+declare const EvaluateInputSchema: z.ZodObject<{
+    sessionId: z.ZodUUID;
+    payment: z.ZodObject<{
+        protocol: z.ZodString;
+        payee: z.ZodString;
+        amount: z.ZodObject<{
+            value: z.ZodString;
+            currency: z.ZodString;
+        }, z.core.$strict>;
+        payer: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, 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>;
+declare const AnchorEntrySchema: z.ZodObject<{
+    epoch: z.ZodString;
+    root: z.ZodString;
+    sig: z.ZodString;
+    chainRef: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type AnchorEntry = z.infer<typeof AnchorEntrySchema>;
+declare const AnchorsOutputSchema: z.ZodObject<{
+    entries: z.ZodArray<z.ZodObject<{
+        epoch: z.ZodString;
+        root: z.ZodString;
+        sig: z.ZodString;
+        chainRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type AnchorsOutput = z.infer<typeof AnchorsOutputSchema>;
+/** Non-RFC admin surface (GAP-53). */
+declare const CreatePolicyInputSchema: z.ZodObject<{
+    rules: z.ZodObject<{
+        rules: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            primitive: z.ZodEnum<{
+                THRESHOLD: "THRESHOLD";
+                MEMBERSHIP: "MEMBERSHIP";
+                MATCH: "MATCH";
+                PRESENCE: "PRESENCE";
+                FRESHNESS: "FRESHNESS";
+            }>;
+            selector: z.ZodString;
+            params: z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+            onFail: z.ZodEnum<{
+                DENY: "DENY";
+                REVIEW: "REVIEW";
+            }>;
+            onMissing: z.ZodOptional<z.ZodEnum<{
+                DENY: "DENY";
+                REVIEW: "REVIEW";
+                skip: "skip";
+            }>>;
+            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>;
+/** Error envelope (GAP-20). */
+declare const ApiErrorSchema: z.ZodObject<{
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        details: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+        request_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+type ApiError = z.infer<typeof ApiErrorSchema>;
+
+declare const SessionOpenPayloadSchema: z.ZodObject<{
+    runtime: z.ZodObject<{
+        sdk: z.ZodString;
+        version: z.ZodString;
+        framework: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+    }, 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";
+        settled: "settled";
+        aborted: "aborted";
+        expired: "expired";
+    }>;
+    transaction: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+declare const IntentDeclaredPayloadSchema: z.ZodObject<{
+    mandate: z.ZodString;
+    maxAmount: z.ZodOptional<z.ZodObject<{
+        value: z.ZodString;
+        currency: z.ZodString;
+    }, z.core.$strict>>;
+    merchantAllowlist: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    validUntil: z.ZodISODateTime;
+}, 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>>>;
+}, z.core.$loose>;
+declare const LlmCallEndPayloadSchema: z.ZodObject<{
+    callId: z.ZodString;
+    content: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+    finishReason: z.ZodOptional<z.ZodString>;
+    usage: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+    durationMs: z.ZodNumber;
+    error: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+declare const ToolCallStartPayloadSchema: z.ZodObject<{
+    callId: z.ZodString;
+    toolName: z.ZodString;
+    input: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    transport: z.ZodOptional<z.ZodEnum<{
+        local: "local";
+        mcp: "mcp";
+    }>>;
+    server: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+declare const ToolCallEndPayloadSchema: z.ZodObject<{
+    callId: z.ZodString;
+    output: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+    error: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        message: z.ZodString;
+    }, 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
+ * the protocol artifact as seen — the log, not a digest of it.
+ */
+declare const PaymentMomentPayloadSchema: z.ZodObject<{
+    protocol: z.ZodString;
+    payee: z.ZodString;
+    amount: z.ZodObject<{
+        value: z.ZodString;
+        currency: z.ZodString;
+    }, z.core.$loose>;
+    payer: z.ZodOptional<z.ZodString>;
+    artifact: z.ZodEnum<{
+        "http-402": "http-402";
+        "mrtr-input-required": "mrtr-input-required";
+        "payment-signature": "payment-signature";
+        "checkout-url": "checkout-url";
+    }>;
+    raw: z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+}, z.core.$loose>;
+declare const GatewayDecisionPayloadSchema: z.ZodObject<{
+    gateway: z.ZodString;
+    call: z.ZodObject<{
+        tool: z.ZodString;
+        args: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+    }, z.core.$loose>;
+    decision: z.ZodEnum<{
+        DENY: "DENY";
+        REVIEW: "REVIEW";
+        ALLOW: "ALLOW";
+        CHALLENGE: "CHALLENGE";
+    }>;
+    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). */
+declare const TransportGapPayloadSchema: z.ZodObject<{
+    dropped: z.ZodNumber;
+    firstTs: z.ZodString;
+    lastTs: z.ZodString;
+}, z.core.$loose>;
+/** Exactly `{ origin, params, response }` so its digest is the Observation digest (GAP-39). */
+declare const PlatformObservationPayloadSchema: z.ZodObject<{
+    origin: z.ZodString;
+    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";
+        seq_gap: "seq_gap";
+        prev_hash_mismatch: "prev_hash_mismatch";
+        bad_sig: "bad_sig";
+        clock_skew: "clock_skew";
+        source_conflict: "source_conflict";
+    }>;
+    source: z.ZodEnum<{
+        AGENT_TRACE: "AGENT_TRACE";
+        INTERNAL_NETWORK: "INTERNAL_NETWORK";
+        PLATFORM: "PLATFORM";
+    }>;
+    seq: z.ZodNullable<z.ZodNumber>;
+    detail: z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+}, z.core.$loose>;
+type SessionOpenPayload = z.infer<typeof SessionOpenPayloadSchema>;
+type SessionClosePayload = z.infer<typeof SessionClosePayloadSchema>;
+type IntentDeclaredPayload = z.infer<typeof IntentDeclaredPayloadSchema>;
+type LlmCallStartPayload = z.infer<typeof LlmCallStartPayloadSchema>;
+type LlmCallEndPayload = z.infer<typeof LlmCallEndPayloadSchema>;
+type ToolCallStartPayload = z.infer<typeof ToolCallStartPayloadSchema>;
+type ToolCallEndPayload = z.infer<typeof ToolCallEndPayloadSchema>;
+type PaymentMomentPayload = z.infer<typeof PaymentMomentPayloadSchema>;
+type GatewayDecisionPayload = z.infer<typeof GatewayDecisionPayloadSchema>;
+type TransportGapPayload = z.infer<typeof TransportGapPayloadSchema>;
+type PlatformObservationPayload = z.infer<typeof PlatformObservationPayloadSchema>;
+type PlatformAnomalyPayload = z.infer<typeof PlatformAnomalyPayloadSchema>;
+declare function payloadSchemaFor(kind: EvidenceKind): z.ZodType;
+interface PayloadByKind {
+    'session.open': SessionOpenPayload;
+    'session.close': SessionClosePayload;
+    'intent.declared': IntentDeclaredPayload;
+    'llm_call.start': LlmCallStartPayload;
+    'llm_call.end': LlmCallEndPayload;
+    'tool_call.start': ToolCallStartPayload;
+    'tool_call.end': ToolCallEndPayload;
+    'payment.requested': PaymentMomentPayload;
+    'payment.presented': PaymentMomentPayload;
+    'gateway.decision': GatewayDecisionPayload;
+    'transport.gap': TransportGapPayload;
+    'platform.observation': PlatformObservationPayload;
+    'platform.anomaly': PlatformAnomalyPayload;
+}
+
+export { Hex64Schema as $, ALL_SOURCES as A, type EvaluateOutput as B, type ChainHead as C, type Decision as D, type EvidenceSourceAll as E, EvaluateOutputSchema as F, type EventResult as G, EventResultSchema as H, type EventResultStatus as I, type JsonObject as J, EventResultStatusSchema as K, type EvidenceAck as L, EvidenceAckSchema as M, type EvidenceBatchInput as N, EvidenceBatchInputSchema as O, type PaymentMomentPayload as P, type EvidenceEnvelope as Q, type EvidenceEvent as R, EvidenceEventSchema as S, type EvidenceKind as T, EvidenceKindSchema as U, type EvidenceSource as V, EvidenceSourceAllSchema as W, EvidenceSourceSchema as X, type GatewayDecisionPayload as Y, GatewayDecisionPayloadSchema as Z, type Hex64 as _, type PaymentSummary as a, type IntentDeclaredPayload as a0, IntentDeclaredPayloadSchema as a1, JsonValueSchema as a2, type LlmCallEndPayload as a3, LlmCallEndPayloadSchema as a4, type LlmCallStartPayload as a5, LlmCallStartPayloadSchema as a6, MAX_BATCH_EVENTS as a7, PAYMENT_ARTIFACTS as a8, PLATFORM_KINDS as a9, WIRE_KINDS as aA, WIRE_SOURCES as aB, type WireEvidenceKind as aC, WireEvidenceKindSchema as aD, compareBySessionSource as aE, compareBySourceSeq as aF, isPlatformKind as aG, isWireKind as aH, payloadSchemaFor as aI, type PayloadByKind as aa, PaymentMomentPayloadSchema as ab, PaymentSummarySchema as ac, type PlatformAnomalyPayload as ad, PlatformAnomalyPayloadSchema as ae, type PlatformEvidenceKind as af, PlatformEvidenceKindSchema as ag, type PlatformObservationPayload as ah, PlatformObservationPayloadSchema as ai, SESSION_CLOSE_REASONS as aj, SOURCE_ORDER as ak, SeqSchema as al, type SessionClosePayload as am, SessionClosePayloadSchema as an, SessionIdSchema as ao, type SessionOpenPayload as ap, SessionOpenPayloadSchema as aq, type Sig as ar, SigSchema as as, TimestampSchema as at, type ToolCallEndPayload as au, ToolCallEndPayloadSchema as av, type ToolCallStartPayload as aw, ToolCallStartPayloadSchema as ax, type TransportGapPayload as ay, TransportGapPayloadSchema as az, type JsonValue as b, ANOMALY_TYPES as c, type Amount as d, AmountSchema as e, type AnchorEntry as f, AnchorEntrySchema as g, type AnchorsOutput as h, AnchorsOutputSchema as i, type ApiError as j, ApiErrorSchema as k, ChainHeadSchema as l, type CreatePolicyInput as m, CreatePolicyInputSchema as n, type CreatePolicyOutput as o, CreatePolicyOutputSchema as p, type CreateSessionInput as q, CreateSessionInputSchema as r, type CreateSessionOutput as s, CreateSessionOutputSchema as t, DecisionSchema as u, type DeclaredIntent as v, DeclaredIntentSchema as w, type DigestedEnvelope as x, type EvaluateInput as y, EvaluateInputSchema as z };

package/dist/index.d.ts

@@ -1,8 +1,9 @@
-export { B as Beltic, a as BelticOptions, C as CorrelationStore, M as MemoryCorrelationStore, S as SDK_VERSION, c as createBeltic } from './client-CVx9LgJC.js';
-import { S as Session } from './session-BMNB1N1g.js';
-export { A as AgentIdentity, a as ApiClient, b as ApiClientOptions, B as BelticApiError, C as ChainRejectedError, D as DEFAULT_TRANSPORT, R as RedactFn, c as SessionBorn, d as Sessions, e as StartSessionInput, T as Transport, f as TransportClosedError, g as TransportOptions, h as ephemeralIdentity, i as fileIdentity, j as identityFromSeed } from './session-BMNB1N1g.js';
-import { PaymentSummary, JsonObject, PaymentMomentPayload } from './api.js';
-import './base58.js';
+export { B as Beltic, a as BelticOptions, C as CorrelationStore, E as Evaluation, M as MemoryCorrelationStore, S as SDK_VERSION, c as createBeltic } from './client-C-mV_3A0.js';
+import { S as Session } from './session-5TClPLI4.js';
+export { A as AgentIdentity, a as ApiClient, b as ApiClientOptions, B as BelticApiError, C as ChainRejectedError, D as DEFAULT_OPEN_RETRY_MS, c as DEFAULT_TRANSPORT, O as OpenSessionInput, R as RedactFn, d as SessionBorn, e as Sessions, f as StartSessionInput, T as ToolCallSpan, g as Transport, h as TransportClosedError, i as TransportOptions, j as ephemeralIdentity, k as fileIdentity, l as identityFromSeed } from './session-5TClPLI4.js';
+import { a as PaymentSummary, J as JsonObject, P as PaymentMomentPayload } from './index-Bjs3BPPU.js';
+import './verdict-BAahb5po.js';
+import 'zod';
 
 /**
  * The shape the platform judges (`PaymentSummary`) and the shape the record
@@ -11,15 +12,16 @@ import './base58.js';
  * sides of one purchase compare (`EVIDENCE_MISMATCH`, GAP-50).
  */
 
-declare function summaryOf(m: PaymentMomentPayload): PaymentSummary;
+declare function summaryOf(m: PaymentSummary | PaymentMomentPayload): PaymentSummary;
 /** A presentation the seller side saw as a signed payment, in any protocol. */
 declare function presentedFrom(summary: PaymentSummary, raw: JsonObject): PaymentMomentPayload;
 
 /**
  * One instrumented call = a `*.start` event, the work, a `*.end` event
  * carrying the outcome or the error (GAP-07 correlates them by `callId`).
- * The AI middleware, the tool wrapper and the MCP client all record the
- * same way.
+ * `openCall` is the span; `recordCall` runs the work inside one. The AI
+ * middleware, the tool wrapper, the MCP client and a host's own tool loop
+ * (`Session.toolCall`) all record the same way.
  */
 
 type CallKind = 'llm_call' | 'tool_call';