@paybond/kit 0.11.10 → 0.12.0

package/dist/agent/interceptor.js

@@ -2,6 +2,8 @@ import { evictExpiredAuthorizationCache, takeValidCachedAuthorization, } from ".
 import { buildAutoEvidencePayload } from "./evidence.js";
 import { signHarborEvidenceSubmitRecognitionProof } from "../agent-recognition.js";
 import { signPayeeEvidenceBinding } from "../payee-evidence.js";
+import { AGENT_RECEIPT_KIND_V1, AGENT_RECEIPT_SCHEMA_VERSION, AGENT_RECEIPT_SCOPE_ACTION, AGENT_RECEIPT_SIGNING_ALGORITHM_ED25519, AGENT_RECEIPT_VERSION_V1, actionReceiptId, agentReceiptMessageDigestSha256Hex, valueDigestSha256Hex, } from "../agent-receipt.js";
+import { resolveExternalAttestations, } from "../agent-receipt-external-attestations.js";
 import { PaybondAutoEvidenceSubmitError, PaybondUnregisteredSideEffectingToolError, } from "./types.js";
 export { PaybondAutoEvidenceSubmitError, PaybondEvidenceSubmitError } from "./types.js";
 function nowRfc3339Seconds() {
@@ -27,6 +29,8 @@ function mapSandboxEvidenceResult(result) {
         intentId: result.intent_id,
         predicatePassed: result.predicate_passed ?? undefined,
         sandboxLifecycleStatus: result.sandbox_lifecycle_status,
+        payloadDigestSha256Hex: result.payload_digest?.trim().toLowerCase() || undefined,
+        artifactsDigestSha256Hex: result.artifacts_digest?.trim().toLowerCase() || undefined,
     };
 }
 function isSpendApprovalRequiredError(err) {
@@ -227,11 +231,14 @@ export class PaybondToolInterceptor {
             });
             const evidencePolicyDigest = cached?.policyDigest ?? pinnedDigest;
             let auth;
+            let authorizedAtMs;
             if (cached) {
                 auth = cached.auth;
+                authorizedAtMs = cached.cachedAtMs;
             }
             else {
                 auth = await this.binding.guard.assertSpendAuthorized(resolved.authInput);
+                authorizedAtMs = Date.now();
                 this.emitTrace({
                     type: "spend_authorized",
                     runId: this.binding.runId,
@@ -266,6 +273,12 @@ export class PaybondToolInterceptor {
                     });
                 }
                 const evidenceId = evidenceIdempotencyKey(this.binding.intentId, toolCallId);
+                const externalAttestations = this.resolveToolExternalAttestations(resolved.entry, toolResult, {
+                    toolName,
+                    toolCallId,
+                    operation: resolved.operation,
+                    arguments: input.arguments,
+                });
                 const evidence = await this.submitAutoEvidence({
                     entry: resolved.entry,
                     toolName,
@@ -287,8 +300,27 @@ export class PaybondToolInterceptor {
                     evidencePreset: resolved.entry.evidencePreset,
                     sandboxLifecycleStatus: evidence.sandboxLifecycleStatus,
                     predicatePassed: evidence.predicatePassed,
+                    externalAttestations,
                     recordedAt: traceTimestamp(),
                 });
+                const receiptDraft = this.buildReceiptDraft({
+                    toolName: resolved.toolName,
+                    toolCallId: resolved.toolCallId,
+                    operation: resolved.operation,
+                    arguments: input.arguments,
+                    agentSubject: resolved.authInput.agentSubject,
+                    requestedSpendCents: resolved.requestedSpendCents,
+                    currency: resolved.authInput.currency,
+                    vendorId: resolved.authInput.vendorId,
+                    entry: resolved.entry,
+                    auth,
+                    authorizedAtMs,
+                    policyDigest: evidencePolicyDigest,
+                    executeStartedAt,
+                    toolResult,
+                    evidence,
+                    externalAttestations,
+                });
                 return {
                     toolResult,
                     authorization: {
@@ -298,6 +330,7 @@ export class PaybondToolInterceptor {
                         policyDigest: evidencePolicyDigest,
                     },
                     evidence,
+                    receiptDraft,
                 };
             }
             catch (err) {
@@ -344,6 +377,7 @@ export class PaybondToolInterceptor {
                     : Math.min(requestedSpendCents, sandboxSpend);
         }
         requestedSpendCents ??= 0;
+        const agentContext = this.binding.agentContext;
         return {
             toolName,
             toolCallId,
@@ -359,9 +393,12 @@ export class PaybondToolInterceptor {
                 taskId: input.taskId,
                 workflowId: input.workflowId,
                 currency: input.currency,
-                agentSubject: input.agentSubject,
+                agentSubject: input.agentSubject ?? agentContext?.operatorDid,
                 approvalToken: input.approvalToken,
                 idempotencyKey: input.idempotencyKey,
+                modelFamily: agentContext?.modelFamily,
+                configHashHex: agentContext?.configHashHex,
+                promptHashHex: agentContext?.promptHashHex,
             },
         };
     }
@@ -432,11 +469,19 @@ export class PaybondToolInterceptor {
                 : typeof resultRecord.predicatePassed === "boolean"
                     ? resultRecord.predicatePassed
                     : undefined;
+            const payloadDigestSha256Hex = typeof resultRecord.payload_digest === "string"
+                ? resultRecord.payload_digest.trim().toLowerCase() || undefined
+                : undefined;
+            const artifactsDigestSha256Hex = typeof resultRecord.artifacts_digest === "string"
+                ? resultRecord.artifacts_digest.trim().toLowerCase() || undefined
+                : undefined;
             return {
                 submitted: true,
                 intentId: this.binding.intentId,
                 intentState,
                 predicatePassed,
+                payloadDigestSha256Hex,
+                artifactsDigestSha256Hex,
             };
         }
         catch (err) {
@@ -446,4 +491,135 @@ export class PaybondToolInterceptor {
             throw new PaybondAutoEvidenceSubmitError(options.toolResult, err);
         }
     }
+    /**
+     * Composes an unsigned Agent Receipt Standard draft (Phase 1) after a successful
+     * authorize → execute → evidence cycle. Never signed or persisted here; Phase 2 covers
+     * compose/sign/persist. Best-effort: returns `undefined` instead of throwing whenever
+     * required receipt fields (agent context, principal/operator DID, policy template, pinned
+     * policy digest, or a Harbor decision id) are unavailable on this binding or call.
+     */
+    buildReceiptDraft(options) {
+        try {
+            const agentContext = this.binding.agentContext;
+            if (!agentContext?.operatorDid || !agentContext.principalDid || !agentContext.policyTemplateId) {
+                return undefined;
+            }
+            if (!agentContext.configHashHex || !agentContext.promptHashHex) {
+                return undefined;
+            }
+            if (!options.auth.decisionId || !options.policyDigest) {
+                return undefined;
+            }
+            const actorSubject = options.agentSubject ?? agentContext.operatorDid;
+            const bareDigest = options.policyDigest.startsWith("sha256:")
+                ? options.policyDigest.slice("sha256:".length)
+                : options.policyDigest;
+            const completedAtMs = Date.now();
+            const argumentsDigest = valueDigestSha256Hex(options.arguments);
+            let resultDigest;
+            try {
+                resultDigest = valueDigestSha256Hex(options.toolResult);
+            }
+            catch {
+                resultDigest = undefined;
+            }
+            const harborState = options.evidence.intentState ?? options.evidence.sandboxLifecycleStatus ?? "evidence_submitted";
+            let merchant;
+            let evidenceBlock;
+            const payeeDid = this.binding.productionEvidence?.payeeDid;
+            if (payeeDid && options.evidence.payloadDigestSha256Hex) {
+                merchant = {
+                    payee_did: payeeDid,
+                    vendor_id: options.vendorId,
+                };
+                evidenceBlock = {
+                    completion_preset_id: options.entry.evidencePreset,
+                    payload_digest_sha256_hex: options.evidence.payloadDigestSha256Hex,
+                    artifacts_digest_sha256_hex: options.evidence.artifactsDigestSha256Hex,
+                    predicate_passed: options.evidence.predicatePassed ?? false,
+                    payee_did: payeeDid,
+                };
+            }
+            const draft = {
+                schema_version: AGENT_RECEIPT_SCHEMA_VERSION,
+                kind: AGENT_RECEIPT_KIND_V1,
+                receipt_version: AGENT_RECEIPT_VERSION_V1,
+                scope: AGENT_RECEIPT_SCOPE_ACTION,
+                receipt_id: actionReceiptId(this.binding.intentId, options.toolCallId),
+                issued_at: new Date(completedAtMs).toISOString(),
+                tenant_id: this.binding.tenantId,
+                authorization: {
+                    principal_did: agentContext.principalDid,
+                    actor_subject: actorSubject,
+                    agent: {
+                        operator_did: agentContext.operatorDid,
+                        model_family: agentContext.modelFamily,
+                        model_instance_id: agentContext.modelInstanceId,
+                        config_hash_sha256_hex: agentContext.configHashHex,
+                        prompt_hash_sha256_hex: agentContext.promptHashHex,
+                    },
+                    decision_id: options.auth.decisionId,
+                    audit_id: options.auth.auditId,
+                    policy: {
+                        template_id: agentContext.policyTemplateId,
+                        content_digest_sha256_hex: bareDigest,
+                    },
+                    authorized_at: new Date(options.authorizedAtMs).toISOString(),
+                    requested_spend_cents: options.requestedSpendCents,
+                    currency: options.currency ?? "usd",
+                },
+                execution: {
+                    run_id: this.binding.runId,
+                    tool_call_id: options.toolCallId,
+                    tool_name: options.toolName,
+                    operation: options.operation,
+                    arguments_digest_sha256_hex: argumentsDigest,
+                    result_digest_sha256_hex: resultDigest,
+                    outcome: "executed",
+                    started_at: new Date(options.executeStartedAt).toISOString(),
+                    completed_at: new Date(completedAtMs).toISOString(),
+                    duration_ms: completedAtMs - options.executeStartedAt,
+                },
+                merchant,
+                evidence: evidenceBlock,
+                outcome: {
+                    harbor_state: harborState,
+                    spend_reservation_outcome: "consumed",
+                    predicate_passed: options.evidence.predicatePassed ?? undefined,
+                },
+                references: {
+                    intent_id: this.binding.intentId,
+                    settlement_receipt_id: null,
+                },
+                external_attestations: options.externalAttestations ?? [],
+                signing_algorithm: AGENT_RECEIPT_SIGNING_ALGORITHM_ED25519,
+                message_digest_sha256_hex: "",
+                signing_public_key_ed25519_hex: "",
+                ed25519_signature_hex: "",
+            };
+            draft.message_digest_sha256_hex = agentReceiptMessageDigestSha256Hex(draft);
+            return draft;
+        }
+        catch {
+            // Draft composition is always best-effort; never fails tool execution (Phase 1).
+            return undefined;
+        }
+    }
+    resolveToolExternalAttestations(entry, toolResult, ctx) {
+        const mapper = entry.externalAttestationMapper;
+        if (!mapper) {
+            return [];
+        }
+        try {
+            const mapped = mapper(toolResult, ctx);
+            if (!mapped) {
+                return [];
+            }
+            const inputs = Array.isArray(mapped) ? mapped : [mapped];
+            return resolveExternalAttestations(inputs);
+        }
+        catch {
+            return [];
+        }
+    }
 }

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

@@ -0,0 +1,49 @@
+import { type AgentReceiptV1 } from "../agent-receipt.js";
+import type { PaybondAgentInput, PaybondAgentResult } from "./facade.js";
+export type VerifyAgentReceiptV1Result = {
+    valid: boolean;
+    kind: string;
+    receipt_id: string;
+    tenant_id: string;
+    receipt: AgentReceiptV1;
+};
+type AgentReceiptProtocolClient = {
+    getAgentReceiptV1ByID(receiptId: string): Promise<AgentReceiptV1>;
+    getAgentReceiptV1ByIntentToolCall(init: {
+        intentId: string;
+        toolCallId: string;
+    }): Promise<AgentReceiptV1>;
+    verifyAgentReceiptV1(receipt: AgentReceiptV1 | Record<string, unknown>): Promise<VerifyAgentReceiptV1Result>;
+};
+export type GetAgentReceiptInput = {
+    receiptId: string;
+    intentId?: never;
+    toolCallId?: never;
+} | {
+    intentId: string;
+    toolCallId: string;
+    receiptId?: never;
+};
+export type PaybondAgentCallable = ((input: PaybondAgentInput) => Promise<PaybondAgentResult>) & {
+    getReceipt(input: GetAgentReceiptInput): Promise<AgentReceiptV1>;
+    verifyReceipt(receipt: AgentReceiptV1, options?: {
+        offline?: boolean;
+    }): Promise<VerifyAgentReceiptV1Result | AgentReceiptV1>;
+};
+/** Tenant-bound agent quickstart plus receipt fetch/verify helpers. */
+export declare class PaybondAgentFacade {
+    private readonly protocol;
+    private readonly invokeAgent?;
+    constructor(protocol: AgentReceiptProtocolClient, invokeAgent?: ((input: PaybondAgentInput) => Promise<PaybondAgentResult>) | undefined);
+    /** Fetch a signed `paybond.agent_receipt_v1` by receipt id or intent/tool-call lookup. */
+    getReceipt(input: GetAgentReceiptInput): Promise<AgentReceiptV1>;
+    /** Verify a signed agent receipt via Gateway or locally with {@link verifyAgentReceiptV1}. */
+    verifyReceipt(receipt: AgentReceiptV1, options?: {
+        offline?: boolean;
+    }): Promise<VerifyAgentReceiptV1Result | AgentReceiptV1>;
+    /** Opinionated quickstart: resolve policy presets and wire framework tools. */
+    call(input: PaybondAgentInput): Promise<PaybondAgentResult>;
+}
+/** Callable `paybond.agent({...})` surface with receipt helpers attached. */
+export declare function createPaybondAgentCallable(protocol: AgentReceiptProtocolClient, invokeAgent: (input: PaybondAgentInput) => Promise<PaybondAgentResult>): PaybondAgentCallable;
+export {};

package/dist/agent/receipt-client.js

@@ -0,0 +1,45 @@
+import { verifyAgentReceiptV1, } from "../agent-receipt.js";
+/** Tenant-bound agent quickstart plus receipt fetch/verify helpers. */
+export class PaybondAgentFacade {
+    protocol;
+    invokeAgent;
+    constructor(protocol, invokeAgent) {
+        this.protocol = protocol;
+        this.invokeAgent = invokeAgent;
+    }
+    /** Fetch a signed `paybond.agent_receipt_v1` by receipt id or intent/tool-call lookup. */
+    async getReceipt(input) {
+        if ("receiptId" in input && input.receiptId?.trim()) {
+            return this.protocol.getAgentReceiptV1ByID(input.receiptId.trim());
+        }
+        if (input.intentId?.trim() && input.toolCallId?.trim()) {
+            return this.protocol.getAgentReceiptV1ByIntentToolCall({
+                intentId: input.intentId.trim(),
+                toolCallId: input.toolCallId.trim(),
+            });
+        }
+        throw new Error("getReceipt requires receiptId or intentId + toolCallId");
+    }
+    /** Verify a signed agent receipt via Gateway or locally with {@link verifyAgentReceiptV1}. */
+    async verifyReceipt(receipt, options) {
+        if (options?.offline) {
+            return verifyAgentReceiptV1(receipt);
+        }
+        return this.protocol.verifyAgentReceiptV1(receipt);
+    }
+    /** Opinionated quickstart: resolve policy presets and wire framework tools. */
+    async call(input) {
+        if (!this.invokeAgent) {
+            throw new Error("paybond.agent() requires a hosted Paybond session");
+        }
+        return this.invokeAgent(input);
+    }
+}
+/** Callable `paybond.agent({...})` surface with receipt helpers attached. */
+export function createPaybondAgentCallable(protocol, invokeAgent) {
+    const facade = new PaybondAgentFacade(protocol, invokeAgent);
+    const callable = ((input) => facade.call(input));
+    callable.getReceipt = facade.getReceipt.bind(facade);
+    callable.verifyReceipt = facade.verifyReceipt.bind(facade);
+    return callable;
+}

package/dist/agent/registry.js

@@ -32,6 +32,7 @@ function normalizeSideEffecting(sideEffecting) {
             spendCents: policy.spendCents,
             evidencePreset,
             evidenceMapper: policy.evidenceMapper,
+            externalAttestationMapper: policy.externalAttestationMapper,
         });
     }
     return entries;

package/dist/agent/run.d.ts

@@ -16,6 +16,8 @@ type SandboxGuardrailEvidenceResult = {
     intent_id: string;
     sandbox_lifecycle_status: string;
     predicate_passed?: boolean | null;
+    payload_digest?: string;
+    artifacts_digest?: string;
 };
 export type PaybondSubmitProductionEvidenceInput = {
     intentId: string;

package/dist/agent/run.js

@@ -1,5 +1,6 @@
 import { PaybondToolInterceptor } from "./interceptor.js";
 import { PaybondAgentRunBindError, } from "./types.js";
+import { configHashSha256Hex, promptHashSha256Hex } from "../agent-receipt.js";
 import { reloadPolicyOnRun, } from "../policy/reload.js";
 import { PaybondPolicyReloadController } from "../policy/watcher.js";
 import { resolveDevTraceSink } from "../dev/trace-buffer.js";
@@ -45,6 +46,55 @@ function normalizeProductionEvidence(raw, sandbox) {
         agentRecognitionSigningSeed: raw.agentRecognitionSigningSeed,
     };
 }
+/** Strips the leading `sha256:` scheme from a policy snapshot digest, if present. */
+function bareDigestHex(digest) {
+    if (!digest) {
+        return undefined;
+    }
+    const trimmed = digest.trim();
+    return trimmed.startsWith("sha256:") ? trimmed.slice("sha256:".length) : trimmed;
+}
+/**
+ * Resolves optional Agent Receipt Standard agent context at bind time: auto-computes
+ * `config_hash_hex` from {@link PaybondRunAgentContextInput.configHashMaterials} (per spec,
+ * `sha256(JCS({ system_prompt, tools_manifest, policy_snapshot_id }))`) and `prompt_hash_hex`
+ * from {@link PaybondRunAgentContextInput.normalizedUserPrompt} when precomputed hashes are not
+ * supplied directly. Raw prompt text is hashed here and discarded; only the digest is retained.
+ */
+function resolveAgentContext(input, snapshot) {
+    if (!input) {
+        return undefined;
+    }
+    const modelFamily = input.modelFamily.trim();
+    if (!modelFamily) {
+        throw new PaybondAgentRunBindError("agentContext.modelFamily must be non-empty");
+    }
+    let configHashHex = input.configHashHex?.trim().toLowerCase();
+    if (!configHashHex && input.configHashMaterials) {
+        const policySnapshotId = input.configHashMaterials.policySnapshotId?.trim() || bareDigestHex(snapshot?.digest);
+        if (!policySnapshotId) {
+            throw new PaybondAgentRunBindError("agentContext.configHashMaterials.policySnapshotId is required when no policySnapshot is bound");
+        }
+        configHashHex = configHashSha256Hex({
+            system_prompt: input.configHashMaterials.systemPrompt,
+            tools_manifest: input.configHashMaterials.toolsManifest,
+            policy_snapshot_id: policySnapshotId,
+        });
+    }
+    let promptHashHex = input.promptHashHex?.trim().toLowerCase();
+    if (!promptHashHex && input.normalizedUserPrompt !== undefined) {
+        promptHashHex = promptHashSha256Hex(input.normalizedUserPrompt);
+    }
+    return {
+        modelFamily,
+        modelInstanceId: input.modelInstanceId?.trim() || undefined,
+        configHashHex,
+        promptHashHex,
+        principalDid: input.principalDid?.trim() || undefined,
+        operatorDid: input.operatorDid?.trim() || undefined,
+        policyTemplateId: input.policyTemplateId?.trim() || undefined,
+    };
+}
 function assertExclusiveBindMode(input) {
     const hasBootstrap = input.bootstrap !== undefined;
     const hasAttach = input.attach !== undefined;
@@ -268,6 +318,7 @@ export class PaybondAgentRun {
         const registry = snapshot?.registry ?? input.registry;
         registry.validateForBind(allowedTools);
         const guard = paybond.spendGuard(intentId, capabilityToken);
+        const agentContext = resolveAgentContext(input.agentContext, snapshot);
         const binding = {
             runId,
             tenantId,
@@ -280,6 +331,7 @@ export class PaybondAgentRun {
             productionEvidence,
             policySnapshot: snapshot,
             onTrace: input.traceSink ?? input.onTrace ?? resolveDevTraceSink(),
+            agentContext,
         };
         const policyFilePath = input.policyFile?.trim();
         const run = new PaybondAgentRun(binding, paybond, snapshot, policyFilePath);

package/dist/agent/types.d.ts

@@ -1,3 +1,4 @@
+import type { AgentReceiptExternalAttestationV1 } from "../agent-receipt.js";
 /** Context passed to evidence mappers after a successful side-effecting tool call. */
 export type PaybondToolCallContext = {
     toolName: string;
@@ -9,6 +10,8 @@ export type PaybondToolCallContext = {
 export type PaybondSpendResolver<TArgs = unknown> = (args: TArgs) => number | undefined;
 /** Customize auto-evidence payload extraction from a tool result. */
 export type PaybondEvidenceMapper<TResult = unknown> = (result: TResult, ctx: PaybondToolCallContext) => Record<string, unknown>;
+/** Optional partner attestation material for Agent Receipt `external_attestations`. */
+export type PaybondExternalAttestationMapper<TResult = unknown> = (result: TResult, ctx: PaybondToolCallContext) => PaybondExternalAttestationInput | PaybondExternalAttestationInput[] | undefined;
 /** Policy for one registered side-effecting tool. */
 export type PaybondSideEffectingToolPolicy<TArgs = unknown, TResult = unknown> = {
     /** Harbor `allowed_tools` operation; defaults to the registry key (tool name). */
@@ -17,6 +20,7 @@ export type PaybondSideEffectingToolPolicy<TArgs = unknown, TResult = unknown> =
     /** Required completion catalog preset id for auto-evidence. */
     evidencePreset: string;
     evidenceMapper?: PaybondEvidenceMapper<TResult>;
+    externalAttestationMapper?: PaybondExternalAttestationMapper<TResult>;
 };
 export type PaybondToolRegistryConfig = {
     sideEffecting?: Record<string, PaybondSideEffectingToolPolicy>;
@@ -29,6 +33,7 @@ export type PaybondSideEffectingToolEntry = {
     spendCents?: number | PaybondSpendResolver;
     evidencePreset: string;
     evidenceMapper?: PaybondEvidenceMapper;
+    externalAttestationMapper?: PaybondExternalAttestationMapper;
 };
 export type PaybondToolResolution = {
     kind: "passthrough";
@@ -50,6 +55,8 @@ export declare class PaybondToolRegistryValidationError extends Error {
 import type { PaybondToolRegistry } from "./registry.js";
 import type { PaybondPolicySnapshot } from "../policy/snapshot.js";
 import type { PaybondPolicyReloadBindConfig } from "../policy/reload.js";
+import type { AgentReceiptV1 } from "../agent-receipt.js";
+import type { PaybondExternalAttestationInput } from "../agent-receipt-external-attestations.js";
 /** Spend authorization input forwarded to the run-bound guard. */
 export type PaybondRunGuardAuthInput = {
     operation: string;
@@ -63,6 +70,54 @@ export type PaybondRunGuardAuthInput = {
     agentSubject?: string;
     approvalToken?: string;
     idempotencyKey?: string;
+    /** Agent Receipt Standard context forwarded to Gateway `/verify` for audit correlation. */
+    modelFamily?: string;
+    configHashHex?: string;
+    promptHashHex?: string;
+};
+/**
+ * Materials to auto-compute `config_hash_hex` as `sha256(JCS({ system_prompt, tools_manifest,
+ * policy_snapshot_id }))` per the Agent Receipt Standard spec. `policySnapshotId` defaults to
+ * the bound policy snapshot digest (without the `sha256:` prefix) when omitted.
+ */
+export type PaybondRunConfigHashMaterials = {
+    systemPrompt: string;
+    toolsManifest: unknown;
+    policySnapshotId?: string;
+};
+/**
+ * Optional agent identity/config context for {@link PaybondAgentRun.bind}. Threaded onto every
+ * spend verify call and used to compose the unsigned Agent Receipt Standard draft returned from
+ * {@link PaybondToolInterceptor.wrapExecute}. Raw prompts are hashed locally and never retained
+ * or transmitted; only `promptHashHex` is kept on the resolved binding.
+ */
+export type PaybondRunAgentContextInput = {
+    modelFamily: string;
+    modelInstanceId?: string;
+    /** Precomputed sha256 hex digest; mutually exclusive with {@link configHashMaterials}. */
+    configHashHex?: string;
+    /** Auto-computed into `configHashHex` at bind time when `configHashHex` is omitted. */
+    configHashMaterials?: PaybondRunConfigHashMaterials;
+    /** Precomputed sha256 hex digest; mutually exclusive with {@link normalizedUserPrompt}. */
+    promptHashHex?: string;
+    /** Hashed locally at bind time into `promptHashHex`; never stored or transmitted raw. */
+    normalizedUserPrompt?: string;
+    /** Agent receipt `authorization.principal_did`; omitted from receipt drafts when unset. */
+    principalDid?: string;
+    /** Agent receipt `authorization.agent.operator_did`; omitted from receipt drafts when unset. */
+    operatorDid?: string;
+    /** Agent receipt `authorization.policy.template_id`; omitted from receipt drafts when unset. */
+    policyTemplateId?: string;
+};
+/** Resolved agent context stored on the run binding after bind-time hash computation. */
+export type PaybondRunAgentContext = {
+    modelFamily: string;
+    modelInstanceId?: string;
+    configHashHex?: string;
+    promptHashHex?: string;
+    principalDid?: string;
+    operatorDid?: string;
+    policyTemplateId?: string;
 };
 /** Spend authorization result from Harbor verify. */
 export type PaybondRunGuardAuthResult = {
@@ -116,6 +171,10 @@ export type PaybondInterceptEvidenceResult = {
     predicatePassed?: boolean | null;
     sandboxLifecycleStatus?: string;
     intentState?: string;
+    /** sha256 hex digest of the submitted evidence payload, when returned by Harbor. */
+    payloadDigestSha256Hex?: string;
+    /** sha256 hex digest of submitted evidence artifacts, when returned by Harbor. */
+    artifactsDigestSha256Hex?: string;
 };
 export type PaybondInterceptWrapExecuteResult<TResult> = {
     toolResult: TResult;
@@ -126,6 +185,12 @@ export type PaybondInterceptWrapExecuteResult<TResult> = {
         policyDigest?: string;
     };
     evidence?: PaybondInterceptEvidenceResult;
+    /**
+     * Unsigned Agent Receipt Standard draft (Phase 1: composed locally, never signed or persisted).
+     * Omitted when required context (agentContext hashes, principal/operator DID, policy template,
+     * decision id) is unavailable — receipt composition is always best-effort and never throws.
+     */
+    receiptDraft?: AgentReceiptV1;
 };
 export type PaybondInterceptWrapExecuteInput<TResult> = {
     toolName: string;
@@ -241,6 +306,7 @@ export type PaybondTraceEvidenceSubmittedEvent = {
     evidencePreset?: string;
     sandboxLifecycleStatus?: string;
     predicatePassed?: boolean | null;
+    externalAttestations?: AgentReceiptExternalAttestationV1[];
     recordedAt: string;
 };
 export type PaybondTraceSpendFinalizedEvent = {
@@ -275,6 +341,8 @@ export type PaybondRunBinding = {
     policySnapshot?: PaybondPolicySnapshot;
     /** Optional trace sink for dev observability (see {@link PaybondAgentRunBindInput.traceSink}). */
     onTrace?: PaybondTraceSink;
+    /** Resolved Agent Receipt Standard context, when bound with {@link PaybondAgentRunBindInput.agentContext}. */
+    agentContext?: PaybondRunAgentContext;
 };
 export type PaybondAgentRunBindInput = {
     bootstrap?: PaybondRunBindingSandboxBootstrapInput;
@@ -295,6 +363,8 @@ export type PaybondAgentRunBindInput = {
     traceSink?: PaybondTraceSink;
     /** @deprecated Use {@link PaybondAgentRunBindInput.traceSink}. */
     onTrace?: PaybondTraceSink;
+    /** Optional Agent Receipt Standard agent identity/config context (see {@link PaybondRunAgentContextInput}). */
+    agentContext?: PaybondRunAgentContextInput;
 };
 export declare class PaybondAgentRunBindError extends Error {
     constructor(message: string);

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

@@ -0,0 +1,29 @@
+/**
+ * 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";
+/** 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[];
+export type PaybondExternalAttestationInput = {
+    kind: "sep2828";
+    decision: Record<string, unknown>;
+    outcome: Record<string, unknown>;
+} | {
+    kind: "x402";
+    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[];