@paybond/kit 0.11.11 → 0.12.1

package/dist/agent-receipt-external-attestations.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Maps partner attestation artifacts into Agent Receipt `external_attestations` entries.
+ *
+ * Partner digests are SHA-256 of canonical JSON (signature fields stripped for SEP-2828).
+ * These entries are never canonical inside Paybond; they provide interop hooks only.
+ */
+import type { AgentReceiptExternalAttestationV1 } from "./agent-receipt.js";
+export declare const AGENT_RECEIPT_EXTERNAL_SOURCE_SEP2828 = "sep2828_mcp";
+export declare const AGENT_RECEIPT_EXTERNAL_SOURCE_X402 = "x402";
+export declare const AGENT_RECEIPT_EXTERNAL_SOURCE_AP2 = "ap2";
+/** SHA-256 hex digest of canonical JSON bytes. */
+export declare function partnerRecordDigestSha256Hex(record: Record<string, unknown>): string;
+/**
+ * Converts verified SEP-2828 decision/outcome records into external attestation entries.
+ */
+export declare function sep2828RecordsToExternalAttestations(decisionInput: Record<string, unknown>, outcomeInput: Record<string, unknown>): AgentReceiptExternalAttestationV1[];
+/**
+ * Converts a verified x402 signed delivery receipt into one external attestation entry.
+ */
+export declare function x402ReceiptToExternalAttestations(receiptInput: Record<string, unknown>): AgentReceiptExternalAttestationV1[];
+/**
+ * Converts a verified signed AP2 agent mandate into one external attestation entry.
+ */
+export declare function signedMandateToExternalAttestations(signed: Record<string, unknown>, transportBinding?: {
+    external_authorization_id?: string;
+}): AgentReceiptExternalAttestationV1[];
+/**
+ * Converts a verified AP2 protocol authorization receipt into one external attestation entry.
+ */
+export declare function protocolAuthorizationReceiptToExternalAttestations(receipt: Record<string, unknown>): AgentReceiptExternalAttestationV1[];
+/**
+ * Converts a verified AP2 protocol settlement receipt into one external attestation entry.
+ */
+export declare function protocolSettlementReceiptToExternalAttestations(receipt: Record<string, unknown>): AgentReceiptExternalAttestationV1[];
+export type PaybondExternalAttestationInput = {
+    kind: "sep2828";
+    decision: Record<string, unknown>;
+    outcome: Record<string, unknown>;
+} | {
+    kind: "x402";
+    receipt: Record<string, unknown>;
+} | {
+    kind: "ap2_mandate";
+    signedMandate: Record<string, unknown>;
+    transportBinding?: {
+        external_authorization_id?: string;
+    };
+} | {
+    kind: "ap2_authorization_receipt";
+    receipt: Record<string, unknown>;
+} | {
+    kind: "ap2_settlement_receipt";
+    receipt: Record<string, unknown>;
+} | AgentReceiptExternalAttestationV1;
+/** Resolves pre-built or partner-native attestation inputs into normalized receipt entries. */
+export declare function resolveExternalAttestations(inputs: readonly PaybondExternalAttestationInput[]): AgentReceiptExternalAttestationV1[];

package/dist/agent-receipt-external-attestations.js

@@ -0,0 +1,185 @@
+/**
+ * Maps partner attestation artifacts into Agent Receipt `external_attestations` entries.
+ *
+ * Partner digests are SHA-256 of canonical JSON (signature fields stripped for SEP-2828).
+ * These entries are never canonical inside Paybond; they provide interop hooks only.
+ */
+import { createHash } from "node:crypto";
+import { readString, verifySignedAgentMandateV1 } from "./agent-mandate.js";
+import { normalizeJson } from "./json-digest.js";
+import { verifyProtocolAuthorizationReceiptV1, verifyProtocolSettlementReceiptV1, } from "./protocol-receipt.js";
+import { stripDigestPrefix } from "./mcp-sep2828-evidence.js";
+import { verifySep2828ReceiptPair } from "./sep2828-signature.js";
+import { buildX402ReceiptDigestPayload, } from "./x402-receipt-evidence.js";
+import { extractSignedX402Receipt, verifySignedX402Receipt } from "./x402-receipt-signature.js";
+export const AGENT_RECEIPT_EXTERNAL_SOURCE_SEP2828 = "sep2828_mcp";
+export const AGENT_RECEIPT_EXTERNAL_SOURCE_X402 = "x402";
+export const AGENT_RECEIPT_EXTERNAL_SOURCE_AP2 = "ap2";
+const SEP2828_SIGNATURE_KEYS = new Set([
+    "signature",
+    "ed25519_signature_hex",
+    "message_digest_sha256_hex",
+    "signing_public_key_ed25519_hex",
+]);
+const SEP2828_ASSERTED_BLOCKS = ["issuerAsserted", "receiptAsserted"];
+function readObject(value) {
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    return undefined;
+}
+function canonicalJsonBytes(value) {
+    return new TextEncoder().encode(JSON.stringify(normalizeJson(value)));
+}
+/** SHA-256 hex digest of canonical JSON bytes. */
+export function partnerRecordDigestSha256Hex(record) {
+    return createHash("sha256").update(Buffer.from(canonicalJsonBytes(record))).digest("hex");
+}
+function stripSep2828SignatureFields(record) {
+    const out = {};
+    for (const [key, value] of Object.entries(record)) {
+        if (SEP2828_SIGNATURE_KEYS.has(key)) {
+            continue;
+        }
+        if (SEP2828_ASSERTED_BLOCKS.includes(key)) {
+            const asserted = readObject(value);
+            if (!asserted) {
+                continue;
+            }
+            const stripped = {};
+            for (const [innerKey, innerValue] of Object.entries(asserted)) {
+                if (!SEP2828_SIGNATURE_KEYS.has(innerKey)) {
+                    stripped[innerKey] = innerValue;
+                }
+            }
+            if (Object.keys(stripped).length > 0) {
+                out[key] = stripped;
+            }
+            continue;
+        }
+        out[key] = value;
+    }
+    return out;
+}
+function sep2828RecordDigest(record) {
+    return partnerRecordDigestSha256Hex(stripSep2828SignatureFields(record));
+}
+function x402PayloadDigestSha256Hex(payload) {
+    return partnerRecordDigestSha256Hex(payload);
+}
+/**
+ * Converts verified SEP-2828 decision/outcome records into external attestation entries.
+ */
+export function sep2828RecordsToExternalAttestations(decisionInput, outcomeInput) {
+    verifySep2828ReceiptPair(decisionInput, outcomeInput);
+    const decisionBackLink = readObject(decisionInput.backLink);
+    const referenceID = typeof decisionBackLink?.attestationDigest === "string"
+        ? stripDigestPrefix(decisionBackLink.attestationDigest)
+        : undefined;
+    return [
+        {
+            source: AGENT_RECEIPT_EXTERNAL_SOURCE_SEP2828,
+            kind: "decision_record",
+            digest_sha256_hex: sep2828RecordDigest(decisionInput),
+            reference_id: referenceID,
+        },
+        {
+            source: AGENT_RECEIPT_EXTERNAL_SOURCE_SEP2828,
+            kind: "outcome_record",
+            digest_sha256_hex: sep2828RecordDigest(outcomeInput),
+            reference_id: referenceID,
+        },
+    ];
+}
+/**
+ * Converts a verified x402 signed delivery receipt into one external attestation entry.
+ */
+export function x402ReceiptToExternalAttestations(receiptInput) {
+    const signed = extractSignedX402Receipt(receiptInput);
+    const verifiedPayload = verifySignedX402Receipt(signed);
+    const payload = buildX402ReceiptDigestPayload(verifiedPayload);
+    return [
+        {
+            source: AGENT_RECEIPT_EXTERNAL_SOURCE_X402,
+            kind: "delivery_receipt_v1",
+            digest_sha256_hex: x402PayloadDigestSha256Hex(payload),
+            reference_id: payload.resourceUrl,
+        },
+    ];
+}
+/**
+ * Converts a verified signed AP2 agent mandate into one external attestation entry.
+ */
+export function signedMandateToExternalAttestations(signed, transportBinding) {
+    verifySignedAgentMandateV1(signed);
+    const digest = readString(signed.message_digest_sha256_hex).trim().toLowerCase();
+    const externalAuthorizationId = transportBinding?.external_authorization_id?.trim();
+    const nonce = readString(signed.nonce).trim();
+    const referenceID = externalAuthorizationId || nonce || undefined;
+    return [
+        {
+            source: AGENT_RECEIPT_EXTERNAL_SOURCE_AP2,
+            kind: "agent_mandate_v1",
+            digest_sha256_hex: digest,
+            reference_id: referenceID,
+        },
+    ];
+}
+/**
+ * Converts a verified AP2 protocol authorization receipt into one external attestation entry.
+ */
+export function protocolAuthorizationReceiptToExternalAttestations(receipt) {
+    const verified = verifyProtocolAuthorizationReceiptV1(receipt);
+    return [
+        {
+            source: AGENT_RECEIPT_EXTERNAL_SOURCE_AP2,
+            kind: "protocol_authorization_receipt_v1",
+            digest_sha256_hex: verified.message_digest_sha256_hex,
+            reference_id: verified.intent_id,
+        },
+    ];
+}
+/**
+ * Converts a verified AP2 protocol settlement receipt into one external attestation entry.
+ */
+export function protocolSettlementReceiptToExternalAttestations(receipt) {
+    const verified = verifyProtocolSettlementReceiptV1(receipt);
+    return [
+        {
+            source: AGENT_RECEIPT_EXTERNAL_SOURCE_AP2,
+            kind: "protocol_settlement_receipt_v1",
+            digest_sha256_hex: verified.message_digest_sha256_hex,
+            reference_id: verified.intent_id,
+        },
+    ];
+}
+/** Resolves pre-built or partner-native attestation inputs into normalized receipt entries. */
+export function resolveExternalAttestations(inputs) {
+    const out = [];
+    for (const input of inputs) {
+        if ("source" in input && "digest_sha256_hex" in input) {
+            out.push(input);
+            continue;
+        }
+        if (input.kind === "sep2828") {
+            out.push(...sep2828RecordsToExternalAttestations(input.decision, input.outcome));
+            continue;
+        }
+        if (input.kind === "x402") {
+            out.push(...x402ReceiptToExternalAttestations(input.receipt));
+            continue;
+        }
+        if (input.kind === "ap2_mandate") {
+            out.push(...signedMandateToExternalAttestations(input.signedMandate, input.transportBinding));
+            continue;
+        }
+        if (input.kind === "ap2_authorization_receipt") {
+            out.push(...protocolAuthorizationReceiptToExternalAttestations(input.receipt));
+            continue;
+        }
+        if (input.kind === "ap2_settlement_receipt") {
+            out.push(...protocolSettlementReceiptToExternalAttestations(input.receipt));
+        }
+    }
+    return out;
+}

package/dist/agent-receipt-pdf-export.d.ts

@@ -0,0 +1,43 @@
+import { type AgentReceiptV1, type VerifyAgentReceiptV1Options } from "./agent-receipt.js";
+export declare const AGENT_RECEIPT_PDF_EXPORT_MANIFEST_SCHEMA_VERSION = 1;
+export declare const AGENT_RECEIPT_PDF_EXPORT_MANIFEST_KIND = "paybond.agent_receipt_pdf_export_manifest_v1";
+export declare const AGENT_RECEIPT_PDF_EXPORT_DERIVED_VIEW_LABEL = "Derived from paybond.agent_receipt_v1";
+export declare const FORBIDDEN_PDF_EXPORT_MANIFEST_FIELDS: readonly ["embedded_receipt_json", "receipt_json", "unsigned_receipt", "canonical_receipt", "user_prompt", "system_prompt", "tool_arguments", "tool_results", "evidence_payload", "payee_signature"];
+export type AgentReceiptPDFExportSourceKind = "gateway_fetch" | "audit_export" | "local_file";
+export type AgentReceiptPDFExportFooterStamp = {
+    label: typeof AGENT_RECEIPT_PDF_EXPORT_DERIVED_VIEW_LABEL;
+    receipt_id: string;
+    message_digest_sha256_hex: string;
+    verify_endpoint?: string;
+};
+export type AgentReceiptPDFExportManifest = {
+    schema_version: typeof AGENT_RECEIPT_PDF_EXPORT_MANIFEST_SCHEMA_VERSION;
+    kind: typeof AGENT_RECEIPT_PDF_EXPORT_MANIFEST_KIND;
+    receipt_id: string;
+    message_digest_sha256_hex: string;
+    source_kind: AgentReceiptPDFExportSourceKind;
+    source_artifact?: string;
+    generated_at_rfc3339: string;
+    renderer_id?: string;
+    pdf_sha256_hex?: string;
+    pdf_page_count?: number;
+    derived_view_label: typeof AGENT_RECEIPT_PDF_EXPORT_DERIVED_VIEW_LABEL;
+    footer_stamp: AgentReceiptPDFExportFooterStamp;
+};
+/** Reject authority-embedding fields and validate against the published Draft 2020-12 schema. */
+export declare function validateAgentReceiptPDFExportManifestJSON(value: unknown): AgentReceiptPDFExportManifest;
+export declare function parseAgentReceiptPDFExportManifestJSON(raw: string | Uint8Array): AgentReceiptPDFExportManifest;
+export type GateAgentReceiptPDFExportInput = {
+    receiptJSON: string | Uint8Array;
+    manifestJSON: string | Uint8Array;
+    pdfBytes?: Uint8Array;
+    verifyOptions?: VerifyAgentReceiptV1Options;
+};
+/**
+ * Enforces the PDF export verification gate before rendering or accepting a derived PDF.
+ * Verify signed JSON first, bind manifest/footer stamps, optionally verify PDF bytes hash.
+ */
+export declare function gateAgentReceiptPDFExport(input: GateAgentReceiptPDFExportInput): Promise<{
+    receipt: AgentReceiptV1;
+    manifest: AgentReceiptPDFExportManifest;
+}>;

package/dist/agent-receipt-pdf-export.js

@@ -0,0 +1,109 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Ajv2020 } from "ajv/dist/2020.js";
+import { verifyAgentReceiptV1FromJSON, } from "./agent-receipt.js";
+const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
+const AGENT_RECEIPT_DIR = join(MODULE_DIR, "../../agent-receipt");
+export const AGENT_RECEIPT_PDF_EXPORT_MANIFEST_SCHEMA_VERSION = 1;
+export const AGENT_RECEIPT_PDF_EXPORT_MANIFEST_KIND = "paybond.agent_receipt_pdf_export_manifest_v1";
+export const AGENT_RECEIPT_PDF_EXPORT_DERIVED_VIEW_LABEL = "Derived from paybond.agent_receipt_v1";
+export const FORBIDDEN_PDF_EXPORT_MANIFEST_FIELDS = [
+    "embedded_receipt_json",
+    "receipt_json",
+    "unsigned_receipt",
+    "canonical_receipt",
+    "user_prompt",
+    "system_prompt",
+    "tool_arguments",
+    "tool_results",
+    "evidence_payload",
+    "payee_signature",
+];
+let manifestSchemaValidator;
+function manifestSchemaValidate() {
+    if (!manifestSchemaValidator) {
+        const ajv = new Ajv2020({ allErrors: true, strict: false });
+        const schema = JSON.parse(readFileSync(join(AGENT_RECEIPT_DIR, "pdf-export-manifest-schema.json"), "utf8"));
+        manifestSchemaValidator = ajv.compile(schema);
+    }
+    return manifestSchemaValidator;
+}
+function rejectForbiddenPDFExportManifestFields(value) {
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            rejectForbiddenPDFExportManifestFields(item);
+        }
+        return;
+    }
+    if (!value || typeof value !== "object") {
+        return;
+    }
+    const record = value;
+    for (const [key, child] of Object.entries(record)) {
+        if (FORBIDDEN_PDF_EXPORT_MANIFEST_FIELDS.includes(key)) {
+            throw new Error(`agent receipt pdf export manifest: forbidden field ${JSON.stringify(key)}`);
+        }
+        rejectForbiddenPDFExportManifestFields(child);
+    }
+}
+/** Reject authority-embedding fields and validate against the published Draft 2020-12 schema. */
+export function validateAgentReceiptPDFExportManifestJSON(value) {
+    rejectForbiddenPDFExportManifestFields(value);
+    const validate = manifestSchemaValidate();
+    if (!validate(value)) {
+        throw new Error(`agent receipt pdf export manifest: schema validation failed: ${JSON.stringify(validate.errors ?? [])}`);
+    }
+    return value;
+}
+export function parseAgentReceiptPDFExportManifestJSON(raw) {
+    const text = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        throw new Error("agent receipt pdf export manifest: invalid JSON");
+    }
+    return validateAgentReceiptPDFExportManifestJSON(parsed);
+}
+function assertManifestMatchesReceipt(manifest, receipt) {
+    const receiptId = receipt.receipt_id.trim().toLowerCase();
+    const digest = receipt.message_digest_sha256_hex.trim().toLowerCase();
+    if (manifest.receipt_id.trim().toLowerCase() !== receiptId) {
+        throw new Error("agent receipt pdf export gate: manifest receipt_id does not match verified receipt");
+    }
+    if (manifest.message_digest_sha256_hex.trim().toLowerCase() !== digest) {
+        throw new Error("agent receipt pdf export gate: manifest message_digest_sha256_hex does not match verified receipt");
+    }
+    if (manifest.derived_view_label !== AGENT_RECEIPT_PDF_EXPORT_DERIVED_VIEW_LABEL) {
+        throw new Error(`agent receipt pdf export gate: derived_view_label must be ${JSON.stringify(AGENT_RECEIPT_PDF_EXPORT_DERIVED_VIEW_LABEL)}`);
+    }
+    const stamp = manifest.footer_stamp;
+    if (stamp.receipt_id.trim().toLowerCase() !== receiptId) {
+        throw new Error("agent receipt pdf export gate: footer_stamp receipt_id does not match verified receipt");
+    }
+    if (stamp.message_digest_sha256_hex.trim().toLowerCase() !== digest) {
+        throw new Error("agent receipt pdf export gate: footer_stamp message_digest_sha256_hex does not match verified receipt");
+    }
+    if (stamp.label !== AGENT_RECEIPT_PDF_EXPORT_DERIVED_VIEW_LABEL) {
+        throw new Error(`agent receipt pdf export gate: footer_stamp label must be ${JSON.stringify(AGENT_RECEIPT_PDF_EXPORT_DERIVED_VIEW_LABEL)}`);
+    }
+}
+/**
+ * Enforces the PDF export verification gate before rendering or accepting a derived PDF.
+ * Verify signed JSON first, bind manifest/footer stamps, optionally verify PDF bytes hash.
+ */
+export async function gateAgentReceiptPDFExport(input) {
+    const receipt = await verifyAgentReceiptV1FromJSON(input.receiptJSON, input.verifyOptions);
+    const manifest = parseAgentReceiptPDFExportManifestJSON(input.manifestJSON);
+    assertManifestMatchesReceipt(manifest, receipt);
+    if (input.pdfBytes && manifest.pdf_sha256_hex) {
+        const actual = createHash("sha256").update(input.pdfBytes).digest("hex");
+        if (actual !== manifest.pdf_sha256_hex.trim().toLowerCase()) {
+            throw new Error("agent receipt pdf export gate: pdf_sha256_hex mismatch");
+        }
+    }
+    return { receipt, manifest };
+}

package/dist/agent-receipt-prevalidate.d.ts

@@ -0,0 +1,7 @@
+import type { AgentReceiptV1 } from "./agent-receipt.js";
+/** Privacy-sensitive keys that MUST NOT appear anywhere in agent receipt JSON. */
+export declare const FORBIDDEN_AGENT_RECEIPT_FIELDS: readonly ["user_prompt", "system_prompt", "tool_arguments", "tool_results", "evidence_payload", "payee_signature"];
+/** Reject forbidden privacy fields and validate against the published Draft 2020-12 schema. */
+export declare function validateAgentReceiptJSON(value: unknown): AgentReceiptV1;
+/** Parse and validate untrusted agent receipt JSON before signature verification. */
+export declare function parseAgentReceiptJSON(raw: string | Uint8Array): AgentReceiptV1;

package/dist/agent-receipt-prevalidate.js

@@ -0,0 +1,63 @@
+import { Ajv2020 } from "ajv/dist/2020.js";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
+const AGENT_RECEIPT_DIR = join(MODULE_DIR, "../../agent-receipt");
+/** Privacy-sensitive keys that MUST NOT appear anywhere in agent receipt JSON. */
+export const FORBIDDEN_AGENT_RECEIPT_FIELDS = [
+    "user_prompt",
+    "system_prompt",
+    "tool_arguments",
+    "tool_results",
+    "evidence_payload",
+    "payee_signature",
+];
+let schemaValidator;
+function schemaValidate() {
+    if (!schemaValidator) {
+        const ajv = new Ajv2020({ allErrors: true, strict: false });
+        const schema = JSON.parse(readFileSync(join(AGENT_RECEIPT_DIR, "schema.json"), "utf8"));
+        schemaValidator = ajv.compile(schema);
+    }
+    return schemaValidator;
+}
+function rejectForbiddenAgentReceiptFields(value) {
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            rejectForbiddenAgentReceiptFields(item);
+        }
+        return;
+    }
+    if (!value || typeof value !== "object") {
+        return;
+    }
+    const record = value;
+    for (const [key, child] of Object.entries(record)) {
+        if (FORBIDDEN_AGENT_RECEIPT_FIELDS.includes(key)) {
+            throw new Error(`agent receipt: forbidden field ${JSON.stringify(key)}`);
+        }
+        rejectForbiddenAgentReceiptFields(child);
+    }
+}
+/** Reject forbidden privacy fields and validate against the published Draft 2020-12 schema. */
+export function validateAgentReceiptJSON(value) {
+    rejectForbiddenAgentReceiptFields(value);
+    const validate = schemaValidate();
+    if (!validate(value)) {
+        throw new Error(`agent receipt: schema validation failed: ${JSON.stringify(validate.errors ?? [])}`);
+    }
+    return value;
+}
+/** Parse and validate untrusted agent receipt JSON before signature verification. */
+export function parseAgentReceiptJSON(raw) {
+    const text = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        throw new Error("agent receipt: invalid JSON");
+    }
+    return validateAgentReceiptJSON(parsed);
+}

package/dist/agent-receipt.d.ts

@@ -0,0 +1,154 @@
+export declare const AGENT_RECEIPT_SCHEMA_VERSION = 1;
+export declare const AGENT_RECEIPT_KIND_V1 = "paybond.agent_receipt_v1";
+export declare const AGENT_RECEIPT_VERSION_V1 = "1";
+export declare const AGENT_RECEIPT_SIGNING_ALGORITHM_ED25519 = "ed25519-sha256-json-v1";
+export declare const AGENT_RECEIPT_SCOPE_ACTION = "action";
+export declare const AGENT_RECEIPT_SCOPE_INTENT_TERMINAL = "intent_terminal";
+export declare const AGENT_RECEIPT_WELL_KNOWN_PATH = "/.well-known/agent-receipt-v1.json";
+export declare const AGENT_RECEIPT_SIGNING_KEYS_WELL_KNOWN_PATH = "/.well-known/agent-receipt-signing-keys.json";
+/** Gateway evidence proxy header carrying Kit-verified external attestation digests. */
+export declare const PAYBOND_AGENT_RECEIPT_ATTESTATIONS_HEADER = "x-paybond-agent-receipt-attestations";
+/** Optional agent run id bound to the attestation header for server-side audit. */
+export declare const PAYBOND_AGENT_RECEIPT_SOURCE_RUN_HEADER = "x-paybond-agent-run-id";
+export type AgentReceiptAgentV1 = {
+    operator_did: string;
+    model_family: string;
+    model_instance_id?: string;
+    config_hash_sha256_hex: string;
+    prompt_hash_sha256_hex: string;
+    deployment_epoch?: number;
+};
+export type AgentReceiptPolicyV1 = {
+    template_id: string;
+    version_seq?: number;
+    content_digest_sha256_hex: string;
+    spend_policy_version?: number;
+};
+export type AgentReceiptAuthorizationV1 = {
+    principal_did: string;
+    actor_subject: string;
+    agent: AgentReceiptAgentV1;
+    decision_id: string;
+    audit_id?: string;
+    policy: AgentReceiptPolicyV1;
+    authorized_at: string;
+    requested_spend_cents: number;
+    currency: string;
+    reason_codes?: string[];
+};
+export type AgentReceiptExecutionV1 = {
+    run_id: string;
+    tool_call_id: string;
+    tool_name: string;
+    operation: string;
+    arguments_digest_sha256_hex: string;
+    result_digest_sha256_hex?: string;
+    outcome: "executed" | "denied" | "skipped" | "failed";
+    started_at: string;
+    completed_at: string;
+    duration_ms?: number;
+};
+export type AgentReceiptMerchantV1 = {
+    payee_did: string;
+    vendor_id?: string;
+    vendor_ref_id?: string;
+};
+export type AgentReceiptEvidenceV1 = {
+    completion_preset_id: string;
+    payload_digest_sha256_hex: string;
+    artifacts_digest_sha256_hex?: string;
+    predicate_passed: boolean;
+    payee_did: string;
+    payee_signature_digest_sha256_hex?: string;
+};
+export type AgentReceiptPaymentV1 = {
+    intent_id: string;
+    settlement_rail: string;
+    funding_method?: string;
+    funding_reference?: string;
+    funding_receipt_digest_sha256_hex?: string;
+};
+export type AgentReceiptOutcomeV1 = {
+    harbor_state: string;
+    spend_reservation_outcome?: "consumed" | "released" | "pending" | "none";
+    predicate_passed?: boolean;
+};
+export type AgentReceiptReferencesV1 = {
+    intent_id: string;
+    ledger_seq?: number;
+    settlement_receipt_id?: string | null;
+};
+export type AgentReceiptExternalAttestationV1 = {
+    source: string;
+    kind: string;
+    digest_sha256_hex: string;
+    reference_id?: string;
+};
+export type AgentReceiptOperatorAttestationV1 = {
+    operator_did: string;
+    signing_public_key_ed25519_hex: string;
+    message_digest_sha256_hex: string;
+    ed25519_signature_hex: string;
+};
+export type AgentReceiptV1 = {
+    schema_version: number;
+    kind: string;
+    receipt_version: string;
+    scope: typeof AGENT_RECEIPT_SCOPE_ACTION | typeof AGENT_RECEIPT_SCOPE_INTENT_TERMINAL;
+    receipt_id: string;
+    issued_at: string;
+    tenant_id: string;
+    authorization: AgentReceiptAuthorizationV1;
+    execution?: AgentReceiptExecutionV1;
+    merchant?: AgentReceiptMerchantV1;
+    evidence?: AgentReceiptEvidenceV1;
+    payment?: AgentReceiptPaymentV1;
+    outcome: AgentReceiptOutcomeV1;
+    references: AgentReceiptReferencesV1;
+    external_attestations: AgentReceiptExternalAttestationV1[];
+    operator_attestation?: AgentReceiptOperatorAttestationV1;
+    signing_algorithm: string;
+    message_digest_sha256_hex: string;
+    signing_public_key_ed25519_hex: string;
+    ed25519_signature_hex: string;
+};
+export type ConfigHashInput = {
+    system_prompt: string;
+    tools_manifest: unknown;
+    policy_snapshot_id: string;
+};
+/** Returns sha256(JCS({ system_prompt, tools_manifest, policy_snapshot_id })). */
+export declare function configHashSha256Hex(input: ConfigHashInput): string;
+/** Returns sha256(normalized_user_prompt). */
+export declare function promptHashSha256Hex(normalizedUserPrompt: string): string;
+/** Returns sha256(JCS(value)). */
+export declare function valueDigestSha256Hex(value: unknown): string;
+/** Returns sha256(intent_id + "\\x00" + tool_call_id) as lowercase hex. */
+export declare function actionReceiptId(intentId: string, toolCallId: string): string;
+/** Returns canonical signing bytes for a normalized receipt body. */
+export declare function canonicalAgentReceiptBytes(receipt: AgentReceiptV1): Uint8Array;
+/**
+ * Returns sha256(canonical receipt bytes) as lowercase hex, ignoring any existing
+ * `message_digest_sha256_hex` on the input. Used to compose unsigned receipt drafts
+ * (Agent Receipt Standard Phase 1) and to compute the digest signers must sign over.
+ */
+export declare function agentReceiptMessageDigestSha256Hex(receipt: AgentReceiptV1): string;
+/** Optional trust-anchor checks during agent receipt verification. */
+export type VerifyAgentReceiptV1Options = {
+    /** Lowercase signing_public_key_ed25519_hex values accepted when non-empty. */
+    expectedSigningPublicKeys?: readonly string[];
+    /**
+     * When true, require any operator_attestation signing key to appear in
+     * trustedOperatorPublicKeys (e.g. tenant middleware attach recognition keys). The
+     * operator_did binding to authorization.agent.operator_did is always enforced.
+     */
+    verifyOperatorAgainstRegistry?: boolean;
+    /** Lowercase operator signing pubkeys accepted when the registry check is enabled. */
+    trustedOperatorPublicKeys?: readonly string[];
+};
+/** Validates structure, receipt_id derivation, digest, and detached Ed25519 signature. */
+export declare function verifyAgentReceiptV1(receipt: AgentReceiptV1, options?: VerifyAgentReceiptV1Options): Promise<AgentReceiptV1>;
+/** Validate raw JSON (schema + forbidden fields) then verify signature. */
+export declare function verifyAgentReceiptV1FromJSON(raw: string | Uint8Array | Record<string, unknown>, options?: VerifyAgentReceiptV1Options): Promise<AgentReceiptV1>;
+/** Attach an optional operator counter-signature over the Gateway message digest. */
+export declare function attachOperatorAttestationV1(receipt: AgentReceiptV1, operatorPrivateKeyHex: string, operatorDid: string): Promise<AgentReceiptV1>;