@paybond/kit 0.11.11 → 0.12.1

package/dist/index.js

@@ -4,16 +4,19 @@
  */
 import { buildSignedCreateIntentBody, buildSignedCreateIntentBodyWithPolicyBinding, } from "./principal-intent.js";
 import { signPayeeEvidenceBinding } from "./payee-evidence.js";
-import { PaybondAgentRunFacade, PaybondInstrumentBuilder, createGuardedAgent, createGuardedAgentRunner, createPaybondAgent, createPaybondToolRegistry, instrumentPaybondAgent, instrumentPaybondClaudeAgents, instrumentPaybondLangGraph, instrumentPaybondMCP, instrumentPaybondOpenAI, instrumentPaybondVercel, resolveAgentPolicySource, wrapPaybondTools, } from "./agent/index.js";
+import { PAYBOND_AGENT_RECEIPT_ATTESTATIONS_HEADER, PAYBOND_AGENT_RECEIPT_SOURCE_RUN_HEADER, } from "./agent-receipt.js";
+import { PaybondAgentRunFacade, createPaybondAgentCallable, PaybondInstrumentBuilder, createGuardedAgent, createGuardedAgentRunner, createPaybondAgent, createPaybondToolRegistry, instrumentPaybondAgent, instrumentPaybondClaudeAgents, instrumentPaybondLangGraph, instrumentPaybondMCP, instrumentPaybondOpenAI, instrumentPaybondVercel, resolveAgentPolicySource, wrapPaybondTools, } from "./agent/index.js";
 import { GatewayAgentRunTraceReporter, } from "./agent/gateway-trace-reporter.js";
 import { fetchWithGatewayRetries, gatewayRetryDelayMs, shouldRetryGatewayResponse, } from "./gateway-retry.js";
 import { PaybondAudit, PaybondAuditExports } from "./audit/index.js";
+import { formatPaymentAuthorizationValue, paymentAuthorizationGatewayHeader, readFundPaymentTransportHeaders, } from "./payment-transport.js";
 import { parsePolicyRemoteValidateResponse, policyValidateQueryString, } from "./policy/validate-remote.js";
 import { parsePolicyEffectiveResolveResponse, } from "./policy/load-effective.js";
 import { paybondPolicyPresets } from "./policy/policy-api.js";
 import { paybondSolutionPresets } from "./solutions/api.js";
 import { requireSecureGatewayUrl } from "./gateway-url.js";
 import { executeFundWithX402, } from "./x402-funding.js";
+import { executeFundWithMppCharge, executeFundWithMppSession, } from "./mpp-funding.js";
 function parseVerifyCapabilityBody(body, expectedTenant, expectedIntentId) {
     const tenant = String(body.tenant ?? "");
     const intentId = String(body.intent_id ?? "");
@@ -83,6 +86,12 @@ function verifyCapabilityPayload(input) {
         payload.approval_token = input.approvalToken.trim();
     if (input.idempotencyKey?.trim())
         payload.idempotency_key = input.idempotencyKey.trim();
+    if (input.modelFamily?.trim())
+        payload.model_family = input.modelFamily.trim();
+    if (input.configHashHex?.trim())
+        payload.config_hash_hex = input.configHashHex.trim().toLowerCase();
+    if (input.promptHashHex?.trim())
+        payload.prompt_hash_hex = input.promptHashHex.trim().toLowerCase();
     return payload;
 }
 export const DEFAULT_PAYBOND_GATEWAY_BASE_URL = "https://api.paybond.ai";
@@ -469,7 +478,7 @@ export class HarborClient {
         }
         throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
     }
-    async fetchWithRetries(url, init, { retryBody, retryBodyText, }) {
+    async fetchWithRetries(url, init, { retryBody, retryBodyText, appendAuthorization, } = {}) {
         let lastErr;
         for (let attempt = 0; attempt < this.maxRetries; attempt++) {
             let res;
@@ -479,6 +488,9 @@ export class HarborClient {
                 for (const [k, v] of Object.entries(auth)) {
                     headers.set(k, v);
                 }
+                for (const value of appendAuthorization ?? []) {
+                    headers.append("authorization", value);
+                }
                 res = await fetch(url, { ...init, headers });
             }
             catch (e) {
@@ -600,11 +612,18 @@ export class HarborClient {
         if (options?.paymentSignature?.trim()) {
             headers["payment-signature"] = options.paymentSignature.trim();
         }
+        const appendAuthorization = options?.paymentAuthorization?.trim() !== undefined &&
+            options.paymentAuthorization.trim() !== ""
+            ? [formatPaymentAuthorizationValue(options.paymentAuthorization)]
+            : undefined;
         const res = await this.fetchWithRetries(url, {
             method: "POST",
             headers,
             body: "",
-        }, { retryBodyText: "" });
+        }, {
+            retryBodyText: "",
+            appendAuthorization,
+        });
         const text = await res.text();
         if (![200, 202, 402].includes(res.status)) {
             throw new HarborHttpError(`Harbor fund intent HTTP ${res.status}: ${text}`, {
@@ -614,6 +633,7 @@ export class HarborClient {
             });
         }
         const body = assertJSONObject(JSON.parse(text));
+        const transport = readFundPaymentTransportHeaders(res.headers);
         const tenant = String(body.tenant ?? "");
         if (tenant !== this.tenantId) {
             throw new Error(`fund tenant mismatch: client=${this.tenantId} harbor=${tenant}`);
@@ -636,6 +656,9 @@ export class HarborClient {
             statusCode: res.status,
             paymentRequired: res.headers.get("payment-required") ?? undefined,
             paymentResponse: res.headers.get("payment-response") ?? undefined,
+            wwwAuthenticate: transport.wwwAuthenticate,
+            paymentReceipt: transport.paymentReceipt,
+            cacheControl: transport.cacheControl,
             intentId: echoedIntentId,
             tenant,
             state: body.state,
@@ -912,6 +935,14 @@ export class GatewayHarborClient {
         return gatewayMutationHeaders(proof, {
             ...(headers ?? {}),
             ...(options?.idempotencyKey?.trim() ? { "idempotency-key": options.idempotencyKey.trim() } : {}),
+            ...(options?.agentReceiptAttestations !== undefined
+                ? {
+                    [PAYBOND_AGENT_RECEIPT_ATTESTATIONS_HEADER]: JSON.stringify(options.agentReceiptAttestations),
+                }
+                : {}),
+            ...(options?.agentReceiptSourceRunId?.trim()
+                ? { [PAYBOND_AGENT_RECEIPT_SOURCE_RUN_HEADER]: options.agentReceiptSourceRunId.trim() }
+                : {}),
         });
     }
     async verifyCapability(input) {
@@ -996,9 +1027,13 @@ export class GatewayHarborClient {
         return JSON.parse(text);
     }
     async fundIntent(intentId, options) {
-        const { res, text, url } = await this.postJSON(`/harbor/intents/${encodeURIComponent(intentId)}/fund`, {}, this.mutationHeaders("fundIntent", options, {
+        const paymentHeaders = {
             ...(options.paymentSignature?.trim() ? { "payment-signature": options.paymentSignature.trim() } : {}),
-        }));
+            ...(options.paymentAuthorization?.trim()
+                ? paymentAuthorizationGatewayHeader(options.paymentAuthorization)
+                : {}),
+        };
+        const { res, text, url } = await this.postJSON(`/harbor/intents/${encodeURIComponent(intentId)}/fund`, {}, this.mutationHeaders("fundIntent", options, paymentHeaders));
         if (![200, 202, 402].includes(res.status)) {
             throw new HarborHttpError(`Gateway Harbor fund intent HTTP ${res.status}: ${text}`, {
                 statusCode: res.status,
@@ -1006,12 +1041,16 @@ export class GatewayHarborClient {
                 bodyText: text,
             });
         }
+        const transport = readFundPaymentTransportHeaders(res.headers);
         return parseFundIntentResponse(assertJSONObject(JSON.parse(text)), {
             tenantId: this.tenantId,
             intentId,
             statusCode: res.status,
             paymentRequired: res.headers.get("payment-required") ?? undefined,
             paymentResponse: res.headers.get("payment-response") ?? undefined,
+            wwwAuthenticate: transport.wwwAuthenticate,
+            paymentReceipt: transport.paymentReceipt,
+            cacheControl: transport.cacheControl,
             source: "gateway",
         });
     }
@@ -1159,7 +1198,7 @@ export class PaybondGuardrails {
     }
 }
 const DEFAULT_PRINCIPAL_PATH = "/v1/auth/principal";
-const SETTLEMENT_RAIL_VALUES = new Set(["stripe_connect", "stripe_ach_debit", "x402_usdc_base"]);
+const SETTLEMENT_RAIL_VALUES = new Set(["stripe_connect", "stripe_ach_debit", "stripe_mpp", "x402_usdc_base"]);
 const FRAUD_REVIEW_EVENT_TYPES = new Set([
     "review_open_requested",
     "appeal_requested",
@@ -1211,6 +1250,9 @@ function parseFundIntentResponse(body, init) {
         statusCode: init.statusCode,
         paymentRequired: init.paymentRequired,
         paymentResponse: init.paymentResponse,
+        wwwAuthenticate: init.wwwAuthenticate,
+        paymentReceipt: init.paymentReceipt,
+        cacheControl: init.cacheControl,
         intentId: echoedIntentId,
         tenant,
         state: body.state,
@@ -1360,6 +1402,9 @@ function parseIntentFundingResult(value) {
         settlementRail: readSettlementRailValue(body.settlement_rail, "funding.settlement_rail"),
         harborFundEndpoint: readOptionalString("harbor_fund_endpoint"),
         status: readOptionalString("status"),
+        intent: readOptionalString("intent"),
+        method: readOptionalString("method"),
+        challengeId: readOptionalString("challenge_id"),
         paymentSessionId: readOptionalString("payment_session_id"),
         paymentUrl: readOptionalString("payment_url"),
         stripePaymentIntentId: readOptionalString("stripe_payment_intent_id"),
@@ -1375,6 +1420,17 @@ function parseIntentFundingResult(value) {
         bankName: readOptionalString("bank_name"),
         asset: readOptionalString("asset"),
         network: readOptionalString("network"),
+        settlementAsset: readOptionalString("settlement_asset"),
+        settlementNetwork: readOptionalString("settlement_network"),
+        channelId: readOptionalString("channel_id"),
+        sessionProtocol: readOptionalString("session_protocol"),
+        depositAmountBaseUnits: readOptionalString("deposit_amount_base_units"),
+        acceptedCumulativeBaseUnits: readOptionalString("accepted_cumulative_base_units"),
+        pendingCumulativeBaseUnits: readOptionalString("pending_cumulative_base_units"),
+        descriptorHash: readOptionalString("descriptor_hash"),
+        lastVoucherAt: readOptionalString("last_voucher_at"),
+        lastSettleTxHash: readOptionalString("last_settle_tx_hash"),
+        channelStatus: readOptionalString("channel_status"),
         authorizationId: readOptionalString("authorization_id"),
         captureId: readOptionalString("capture_id"),
         voidId: readOptionalString("void_id"),
@@ -2050,6 +2106,80 @@ export class GatewayProtocolClient {
         }
         return assertJSONObject(JSON.parse(text));
     }
+    async getAgentReceiptV1ByID(receiptId) {
+        const enc = encodeURIComponent(receiptId);
+        const url = `${this.base}protocol/v2/agent-receipts/${enc}`;
+        const res = await this.fetchWithRetries(url, {
+            method: "GET",
+            headers: this.headers(),
+        });
+        const text = await res.text();
+        if (!res.ok) {
+            const parsed = parseGatewayErrorEnvelope(text);
+            throw new ProtocolHttpError(protocolHTTPErrorMessage("agent receipt", res.status, text), {
+                statusCode: res.status,
+                url,
+                bodyText: text,
+                errorCode: parsed.errorCode,
+                errorMessage: parsed.errorMessage,
+            });
+        }
+        const body = assertJSONObject(JSON.parse(text));
+        if (String(body.receipt_id ?? "").trim() !== receiptId) {
+            throw new Error(`agent receipt mismatch: requested=${receiptId} gateway=${String(body.receipt_id ?? "")}`);
+        }
+        if (String(body.tenant_id ?? "").trim() !== this.tenantId) {
+            throw new Error(`agent receipt tenant mismatch: client=${this.tenantId} gateway=${String(body.tenant_id ?? "")}`);
+        }
+        return body;
+    }
+    async getAgentReceiptV1ByIntentToolCall(init) {
+        const params = new URLSearchParams({
+            intent_id: init.intentId,
+            tool_call_id: init.toolCallId,
+        });
+        const url = `${this.base}protocol/v2/agent-receipts?${params.toString()}`;
+        const res = await this.fetchWithRetries(url, {
+            method: "GET",
+            headers: this.headers(),
+        });
+        const text = await res.text();
+        if (!res.ok) {
+            const parsed = parseGatewayErrorEnvelope(text);
+            throw new ProtocolHttpError(protocolHTTPErrorMessage("agent receipt lookup", res.status, text), {
+                statusCode: res.status,
+                url,
+                bodyText: text,
+                errorCode: parsed.errorCode,
+                errorMessage: parsed.errorMessage,
+            });
+        }
+        const body = assertJSONObject(JSON.parse(text));
+        if (String(body.tenant_id ?? "").trim() !== this.tenantId) {
+            throw new Error(`agent receipt tenant mismatch: client=${this.tenantId} gateway=${String(body.tenant_id ?? "")}`);
+        }
+        return body;
+    }
+    async verifyAgentReceiptV1(receipt) {
+        const url = `${this.base}protocol/v2/agent-receipts/verify`;
+        const res = await this.fetchWithRetries(url, {
+            method: "POST",
+            headers: this.headers({ "content-type": "application/json" }),
+            body: JSON.stringify(receipt),
+        });
+        const text = await res.text();
+        if (!res.ok) {
+            const parsed = parseGatewayErrorEnvelope(text);
+            throw new ProtocolHttpError(protocolHTTPErrorMessage("agent receipt verify", res.status, text), {
+                statusCode: res.status,
+                url,
+                bodyText: text,
+                errorCode: parsed.errorCode,
+                errorMessage: parsed.errorMessage,
+            });
+        }
+        return assertJSONObject(JSON.parse(text));
+    }
     async createHarborIntent(init) {
         return this.postJSON("/harbor/intents", init.body, gatewayMutationHeaders(init.recognitionProof, {
             ...(init.idempotencyKey?.trim() ? { "idempotency-key": init.idempotencyKey.trim() } : {}),
@@ -2081,7 +2211,14 @@ function gatewayMutationHeaders(recognitionProof, headers) {
 function encodeRecognitionProofHeader(proof) {
     return Buffer.from(JSON.stringify(proof), "utf8").toString("base64url");
 }
-async function resolveGatewayTenantId(gatewayBaseUrl, apiKey, principalPath, maxRetries, expectedEnvironment) {
+function readPrincipalEnvironment(actualRaw) {
+    const actual = typeof actualRaw === "string" ? actualRaw.trim() : "";
+    if (actual === "live" || actual === "sandbox") {
+        return actual;
+    }
+    return null;
+}
+async function resolveGatewayPrincipal(gatewayBaseUrl, apiKey, principalPath, maxRetries, expectedEnvironment) {
     const base = normalizeBase(gatewayBaseUrl);
     const path = principalPath.startsWith("/") ? principalPath : `/${principalPath}`;
     const url = `${base}${path}`;
@@ -2125,10 +2262,14 @@ async function resolveGatewayTenantId(gatewayBaseUrl, apiKey, principalPath, max
             });
         }
         assertExpectedEnvironment("gateway principal", body.environment, expected, text);
-        return tenant;
+        return { tenantId: tenant, environment: readPrincipalEnvironment(body.environment) };
     }
     throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
 }
+async function resolveGatewayTenantId(gatewayBaseUrl, apiKey, principalPath, maxRetries, expectedEnvironment) {
+    const principal = await resolveGatewayPrincipal(gatewayBaseUrl, apiKey, principalPath, maxRetries, expectedEnvironment);
+    return principal.tenantId;
+}
 /**
  * Read-only tenant-bound Signal session for one service-account API key.
  */
@@ -2217,6 +2358,7 @@ export class PaybondIntents {
     async fund(params) {
         return this.harbor.fundIntent(params.intentId, {
             paymentSignature: params.paymentSignature,
+            paymentAuthorization: params.paymentAuthorization,
             idempotencyKey: params.idempotencyKey,
             recognitionProof: params.recognitionProof,
         });
@@ -2242,6 +2384,52 @@ export class PaybondIntents {
             }),
         });
     }
+    /**
+     * One-shot Stripe MPP charge fund flow: create Payment Auth credentials from 402 challenges,
+     * retry with `paymentAuthorization`, and poll until funded.
+     *
+     * MPP wallet and SPT secrets stay app-owned — pass injectable `createPaymentCredential` and
+     * `issueRecognitionProof` callbacks.
+     */
+    async fundWithMppCharge(params) {
+        const { intentId, recognitionProof, createPaymentCredential, issueRecognitionProof, pollOptions, idempotencyKey, } = params;
+        return executeFundWithMppCharge({
+            intentId,
+            recognitionProof,
+            createPaymentCredential,
+            issueRecognitionProof,
+            pollOptions,
+            fund: ({ recognitionProof: proof, paymentAuthorization }) => this.fund({
+                intentId,
+                recognitionProof: proof,
+                paymentAuthorization,
+                idempotencyKey,
+            }),
+        });
+    }
+    /**
+     * Tempo MPP session fund flow: open a session channel deposit via Payment Auth credentials,
+     * retry with `paymentAuthorization`, and poll until the intent is funded.
+     *
+     * MPP wallet and SPT secrets stay app-owned — pass injectable `createPaymentCredential` and
+     * `issueRecognitionProof` callbacks.
+     */
+    async fundWithMppSession(params) {
+        const { intentId, recognitionProof, createPaymentCredential, issueRecognitionProof, pollOptions, idempotencyKey, } = params;
+        return executeFundWithMppSession({
+            intentId,
+            recognitionProof,
+            createPaymentCredential,
+            issueRecognitionProof,
+            pollOptions,
+            fund: ({ recognitionProof: proof, paymentAuthorization }) => this.fund({
+                intentId,
+                recognitionProof: proof,
+                paymentAuthorization,
+                idempotencyKey,
+            }),
+        });
+    }
     /**
      * Sign payee evidence and POST it. `payeeSigningSeed` must be 32 bytes.
      */
@@ -2277,7 +2465,15 @@ export class Paybond {
     intents;
     audit;
     agentRun;
-    constructor(harbor, guardrails, signal, fraud, a2a, protocol, audit) {
+    agent;
+    /**
+     * Deployment environment this session is bound to, as reported by the gateway principal
+     * (`"live"` or `"sandbox"`), or `null` when the gateway did not report one. Server-derived —
+     * prefer this over the client-supplied `expectedEnvironment` hint when gating environment-sensitive
+     * behavior (for example, refusing live Stripe secrets in a sandbox-only demo).
+     */
+    environment;
+    constructor(harbor, guardrails, signal, fraud, a2a, protocol, audit, environment) {
         this.harbor = harbor;
         this.guardrails = guardrails;
         this.signal = signal;
@@ -2287,12 +2483,15 @@ export class Paybond {
         this.intents = new PaybondIntents(harbor);
         this.audit = audit;
         this.agentRun = new PaybondAgentRunFacade(this);
+        this.agent = createPaybondAgentCallable(protocol, (input) => createPaybondAgent(this, input));
+        this.environment = environment;
     }
     /** Open a tenant-bound hosted Paybond session from a service-account API key. */
     static async open(init) {
         const gatewayBaseUrl = defaultGatewayBaseUrl(init.gatewayBaseUrl);
         const maxRetries = Math.max(1, init.maxRetries ?? 3);
-        const tenantId = await resolveGatewayTenantId(gatewayBaseUrl, init.apiKey, init.principalPath ?? DEFAULT_PRINCIPAL_PATH, maxRetries, init.expectedEnvironment);
+        const principal = await resolveGatewayPrincipal(gatewayBaseUrl, init.apiKey, init.principalPath ?? DEFAULT_PRINCIPAL_PATH, maxRetries, init.expectedEnvironment);
+        const tenantId = principal.tenantId;
         const harbor = new GatewayHarborClient(gatewayBaseUrl, tenantId, {
             staticGatewayBearerToken: init.apiKey,
             maxRetries,
@@ -2321,7 +2520,7 @@ export class Paybond {
             staticGatewayBearerToken: init.apiKey,
             maxRetries,
         }));
-        return new Paybond(harbor, guardrails, signal, fraud, a2a, protocol, audit);
+        return new Paybond(harbor, guardrails, signal, fraud, a2a, protocol, audit, principal.environment);
     }
     /** Reserved for future HTTP client cleanup; safe to call after work completes. */
     async aclose() {
@@ -2373,13 +2572,6 @@ export class Paybond {
     instrumentMCP(input) {
         return instrumentPaybondMCP(this, input);
     }
-    /**
-     * Opinionated quickstart: resolve named policy presets (for example `travel`) or file paths,
-     * then instrument tools for the selected framework.
-     */
-    agent(input) {
-        return createPaybondAgent(this, input);
-    }
     /** Wrap tools for an existing bound run without reloading policy. */
     wrapTools(run, tools, options) {
         return wrapPaybondTools(run, tools, options);
@@ -2405,6 +2597,10 @@ export { buildSignedCreateIntentBody, buildSignedCreateIntentBodyWithPolicyBindi
 export { artifactsDigest, evidenceSignBytesV1, signPayeeEvidenceBinding, } from "./payee-evidence.js";
 export { AGENT_RECOGNITION_GATEWAY_VERIFIER_ID, AGENT_RECOGNITION_PROOF_KIND_V1, AGENT_RECOGNITION_PURPOSE_CREATE, AGENT_RECOGNITION_PURPOSE_FUND, AGENT_RECOGNITION_PURPOSE_EVIDENCE_SUBMIT, newAgentRecognitionRequestEnvelope, signAgentRecognitionProofV1, signHarborCreateRecognitionProof, signHarborFundRecognitionProof, signHarborEvidenceSubmitRecognitionProof, signHarborSettlementConfirmRecognitionProof, } from "./agent-recognition.js";
 export { executeFundWithX402, buildX402FundRequestEnvelope, PaybondX402FundingFailedError, PaybondX402FundingPendingError, } from "./x402-funding.js";
+export { executeFundWithMpp, executeFundWithMppCharge, executeFundWithMppSession, buildMppFundRequestEnvelope, parsePaymentAuthChallenge, selectMppChargeChallenge, selectMppSessionChallenge, PaybondMppFundingFailedError, PaybondMppFundingPendingError, } from "./mpp-funding.js";
+export { buildPaybondStripeMetadata, assertNotStripeFundingWebhook, mapStripeToolResultToEvidence, STRIPE_COMMERCE_MAPPER_VERSION, PAYBOND_STRIPE_METADATA_TENANT_ID_KEY, PAYBOND_STRIPE_METADATA_INTENT_ID_KEY, PAYBOND_STRIPE_METADATA_RAIL_KEY, } from "./stripe-commerce/index.js";
+export { PAYBOND_UCP_AGENT_PROFILE_URL, PAYBOND_SHOPIFY_UCP_VERSION, SHOPIFY_COMMERCE_MAPPER_VERSION, assertNotShopifyFundingWebhook, createCheckoutWithBinding, createGuardedShopifyCheckoutHandler, getOrder, instrumentShopifyCheckout, mapShopifyToolResultToEvidence, mergeBindingIntoCheckoutPayload, toUcpCheckoutLineItems, } from "./shopify/index.js";
+export { normalizeCommerceBinding, encodeCommerceBindingToStripeMetadata, decodeCommerceBindingFromStripeMetadata, encodeCommerceBindingToShopifyNoteAttributes, decodeCommerceBindingFromShopifyNoteAttributes, PAYBOND_COMMERCE_BINDING_TENANT_ID_KEY, PAYBOND_COMMERCE_BINDING_INTENT_ID_KEY, } from "./commerce-binding.js";
 export { validateCompletionEvidence, } from "./completion-validate-evidence.js";
 export { completionSchemaDigestHex, computeVendorContractDigests, verifyVendorContract, verifyCatalogVendorContracts, } from "./completion-contract-digest.js";
 export { contractSnapshotForPreset, mapVendorEvidenceToCanonical, resolveCompletionPreset, } from "./completion-resolve.js";
@@ -2412,3 +2608,10 @@ export { PaybondAgentRun, PaybondAgentRunBindError, PaybondAgentRunFacade, Paybo
 export { PaybondAudit, PaybondAuditExports, GatewayAuditExportsClient, parseAuditExportList, parseAuditExportJobGet, verifyAuditManifest, verifyAuditBundleLocal, } from "./audit/index.js";
 export { PaybondPolicy, composePolicyLayers, composeBundledPresetDefault, domain, guardrails, paybondPolicyPresets, resolveComposedPresetDocument, } from "./policy/index.js";
 export { getSolutionSmokeDefaults, isKnownSolutionId, listSolutionIds, loadSolutionManifest, paybondSolutionPresets, } from "./solutions/index.js";
+export { appendDirectHarborPaymentAuthorization, formatPaymentAuthorizationValue, PAYBOND_PAYMENT_AUTHORIZATION_HEADER, PAYMENT_TRANSPORT_RESPONSE_HEADERS, paymentAuthorizationGatewayHeader, readFundPaymentTransportHeaders, } from "./payment-transport.js";
+export { AGENT_RECEIPT_KIND_V1, AGENT_RECEIPT_SCHEMA_VERSION, AGENT_RECEIPT_SCOPE_ACTION, AGENT_RECEIPT_SCOPE_INTENT_TERMINAL, AGENT_RECEIPT_SIGNING_ALGORITHM_ED25519, AGENT_RECEIPT_VERSION_V1, AGENT_RECEIPT_SIGNING_KEYS_WELL_KNOWN_PATH, AGENT_RECEIPT_WELL_KNOWN_PATH, PAYBOND_AGENT_RECEIPT_ATTESTATIONS_HEADER, PAYBOND_AGENT_RECEIPT_SOURCE_RUN_HEADER, actionReceiptId, attachOperatorAttestationV1, canonicalAgentReceiptBytes, configHashSha256Hex, promptHashSha256Hex, valueDigestSha256Hex, verifyAgentReceiptV1, verifyAgentReceiptV1FromJSON, } from "./agent-receipt.js";
+export { FORBIDDEN_AGENT_RECEIPT_FIELDS, parseAgentReceiptJSON, validateAgentReceiptJSON, } from "./agent-receipt-prevalidate.js";
+export { AGENT_RECEIPT_EXTERNAL_SOURCE_AP2, AGENT_RECEIPT_EXTERNAL_SOURCE_SEP2828, AGENT_RECEIPT_EXTERNAL_SOURCE_X402, partnerRecordDigestSha256Hex, protocolAuthorizationReceiptToExternalAttestations, protocolSettlementReceiptToExternalAttestations, resolveExternalAttestations, sep2828RecordsToExternalAttestations, signedMandateToExternalAttestations, x402ReceiptToExternalAttestations, } from "./agent-receipt-external-attestations.js";
+export { AGENT_RECEIPT_PDF_EXPORT_DERIVED_VIEW_LABEL, AGENT_RECEIPT_PDF_EXPORT_MANIFEST_KIND, AGENT_RECEIPT_PDF_EXPORT_MANIFEST_SCHEMA_VERSION, FORBIDDEN_PDF_EXPORT_MANIFEST_FIELDS, gateAgentReceiptPDFExport, parseAgentReceiptPDFExportManifestJSON, validateAgentReceiptPDFExportManifestJSON, } from "./agent-receipt-pdf-export.js";
+export { AGENT_AUTHORIZATION_KIND_PRINCIPAL, AGENT_AUTHORIZATION_KIND_TENANT, AGENT_MANDATE_KIND_V1, AGENT_MANDATE_SCHEMA_VERSION, AGENT_MANDATE_SIGNING_ALGORITHM_ED25519_SHA256, CONSTRAINT_REFERENCE_KIND_POLICY, CONSTRAINT_REFERENCE_KIND_PREDICATE, HUMAN_PRESENCE_MODE_HUMAN_NOT_PRESENT, HUMAN_PRESENCE_MODE_HUMAN_PRESENT, agentMandateDigestSha256Hex, canonicalAgentMandateJsonBytes, normalizeAgentMandateV1, signAgentMandateV1, verifySignedAgentMandateV1, } from "./agent-mandate.js";
+export { PROTOCOL_AUTHORIZATION_RECEIPT_KIND_V1, PROTOCOL_RECEIPT_SCHEMA_VERSION, PROTOCOL_RECEIPT_SIGNING_ALGORITHM_ED25519_SHA256, PROTOCOL_RECEIPT_STATUS_AUTHORIZED, PROTOCOL_RECEIPT_VERSION_V1, PROTOCOL_SETTLEMENT_RECEIPT_KIND_V1, PROTOCOL_SOURCE_ACP, PROTOCOL_SOURCE_AP2, PROTOCOL_SOURCE_UCP, normalizeProtocolAuthorizationReceiptV1, normalizeProtocolSettlementReceiptV1, signProtocolAuthorizationReceiptV1, signProtocolSettlementReceiptV1, verifyProtocolAuthorizationReceiptV1, verifyProtocolSettlementReceiptV1, } from "./protocol-receipt.js";

package/dist/mcp-receipt-resource.d.ts

@@ -0,0 +1,10 @@
+/** MCP resource URI helpers for tenant-bound agent receipt handoff. */
+export declare const MCP_AGENT_RECEIPT_RESOURCE_SCHEME = "paybond";
+export declare const MCP_AGENT_RECEIPT_RESOURCE_HOST = "receipt";
+export declare const MCP_AGENT_RECEIPT_RESOURCE_URI_TEMPLATE = "paybond://receipt/{receipt_id}";
+export declare const MCP_AGENT_RECEIPT_RESOURCE_MIME_TYPE = "application/json";
+/** Parse `paybond://receipt/{receipt_id}` into a canonical receipt id. */
+export declare function parseAgentReceiptResourceUri(uri: string): string;
+/** Build the MCP resource URI for one signed agent receipt id. */
+export declare function agentReceiptResourceUri(receiptId: string): string;
+export declare function agentReceiptResourceTemplateDefinition(): Record<string, unknown>;

package/dist/mcp-receipt-resource.js

@@ -0,0 +1,32 @@
+/** MCP resource URI helpers for tenant-bound agent receipt handoff. */
+export const MCP_AGENT_RECEIPT_RESOURCE_SCHEME = "paybond";
+export const MCP_AGENT_RECEIPT_RESOURCE_HOST = "receipt";
+export const MCP_AGENT_RECEIPT_RESOURCE_URI_TEMPLATE = "paybond://receipt/{receipt_id}";
+export const MCP_AGENT_RECEIPT_RESOURCE_MIME_TYPE = "application/json";
+const RECEIPT_URI_RE = /^paybond:\/\/receipt\/([0-9a-f]{64}|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i;
+/** Parse `paybond://receipt/{receipt_id}` into a canonical receipt id. */
+export function parseAgentReceiptResourceUri(uri) {
+    const trimmed = uri.trim();
+    const match = RECEIPT_URI_RE.exec(trimmed);
+    if (!match) {
+        throw new Error(`unsupported resource URI ${trimmed}; expected ${MCP_AGENT_RECEIPT_RESOURCE_URI_TEMPLATE}`);
+    }
+    return match[1].toLowerCase();
+}
+/** Build the MCP resource URI for one signed agent receipt id. */
+export function agentReceiptResourceUri(receiptId) {
+    const normalized = receiptId.trim().toLowerCase();
+    if (!RECEIPT_URI_RE.test(`paybond://receipt/${normalized}`)) {
+        throw new Error("receipt_id must be a lowercase SHA-256 hex digest or canonical UUID");
+    }
+    return `paybond://receipt/${normalized}`;
+}
+export function agentReceiptResourceTemplateDefinition() {
+    return {
+        uriTemplate: MCP_AGENT_RECEIPT_RESOURCE_URI_TEMPLATE,
+        name: "paybond_agent_receipt",
+        title: "Paybond Agent Receipt",
+        description: "Signed paybond.agent_receipt_v1 JSON fetched tenant-bound from Gateway GET /protocol/v2/agent-receipts/{receipt_id}.",
+        mimeType: MCP_AGENT_RECEIPT_RESOURCE_MIME_TYPE,
+    };
+}

package/dist/mcp-server.d.ts

@@ -44,6 +44,13 @@ export declare class PaybondMCPServer {
     private readonly toolPolicy;
     private initialized;
     constructor(settings: PaybondMCPSettings);
+    listResourceTemplates(): Array<Record<string, unknown>>;
+    readResource(uri: string): Promise<{
+        uri: string;
+        mimeType: string;
+        text: string;
+        _meta?: Record<string, unknown>;
+    }>;
     listTools(): Array<Record<string, unknown>>;
     callTool(name: string, args?: Record<string, unknown>): Promise<MCPCallToolResult>;
     handleMessage(message: JSONRPCRequest): Promise<JSONRPCResponse | null>;

package/dist/mcp-server.js

@@ -11,9 +11,11 @@ import { MCP_TOOL_ALLOWLIST_ENV, MCP_TOOL_POLICY_ENV, mergeMcpToolPolicy, parseM
 import { MCP_EVIDENCE_POLICY_ENV, McpEvidenceValidationGate, completionEvidenceValidationOk, extractHarborEvidenceValidationInput, extractSandboxGuardrailValidationInput, parseMcpEvidencePolicy, } from "./mcp-evidence-policy.js";
 import { McpCapabilityTokenCache, mcpToolStoresCapabilityToken, parseMcpCapabilityTokenCacheConfig, } from "./mcp-capability-token-cache.js";
 import { createMcpPolicyGatewayAdapter, McpPolicyReloadGate, parseMcpPolicyReloadConfig, } from "./mcp-policy-reload.js";
+import { verifyAgentReceiptV1FromJSON } from "./agent-receipt.js";
+import { agentReceiptResourceTemplateDefinition, agentReceiptResourceUri, MCP_AGENT_RECEIPT_RESOURCE_MIME_TYPE, parseAgentReceiptResourceUri, } from "./mcp-receipt-resource.js";
 import { DEFAULT_PAYBOND_GATEWAY_BASE_URL, GatewayFraudClient, GatewaySignalClient, } from "./index.js";
 const SERVER_NAME = "Paybond MCP";
-const SERVER_VERSION = "0.11.11";
+const SERVER_VERSION = "0.12.1";
 const MCP_PROTOCOL_VERSION = "2025-11-25";
 const DEFAULT_PRINCIPAL_PATH = "/v1/auth/principal";
 const DEFAULT_RECOGNITION_VERIFIER_ID = "paybond-gateway";
@@ -846,6 +848,22 @@ class PaybondMCPRuntime {
             "x-tenant-id": await this.tenantId(),
         });
     }
+    async getAgentReceiptV1(receiptId) {
+        const normalized = receiptId.trim().toLowerCase();
+        const body = await this.gateway.getJSON(`/protocol/v2/agent-receipts/${encodeURIComponent(normalized)}`, {
+            "x-tenant-id": await this.tenantId(),
+        });
+        const expectedTenant = await this.tenantId();
+        const echoedTenant = String(body.tenant_id ?? "").trim();
+        if (echoedTenant !== expectedTenant) {
+            throw new Error(`tenant mismatch: expected=${expectedTenant} gateway=${echoedTenant}`);
+        }
+        const echoedReceipt = String(body.receipt_id ?? "").trim().toLowerCase();
+        if (echoedReceipt !== normalized) {
+            throw new Error(`receipt mismatch: requested=${normalized} gateway=${echoedReceipt}`);
+        }
+        return body;
+    }
     async createHarborIntent(init) {
         return this.gateway.postJSON("/harbor/intents", init.body, gatewayMutationHeaders(await this.tenantId(), init.recognitionProof, optionalMutationHeaders(init.idempotencyKey)));
     }
@@ -896,6 +914,31 @@ export class PaybondMCPServer {
         this.runtime = new PaybondMCPRuntime(settings);
         this.tools = this.buildTools(settings).filter((tool) => toolAllowedByPolicy(tool.name, tool.annotations, this.toolPolicy));
     }
+    listResourceTemplates() {
+        return [agentReceiptResourceTemplateDefinition()];
+    }
+    async readResource(uri) {
+        const receiptId = parseAgentReceiptResourceUri(uri);
+        const receipt = await this.runtime.getAgentReceiptV1(receiptId);
+        let verified;
+        try {
+            verified = await verifyAgentReceiptV1FromJSON(receipt);
+        }
+        catch (err) {
+            throw new Error(`agent receipt verification failed for ${receiptId}: ${formatError(err)}`);
+        }
+        return {
+            uri: agentReceiptResourceUri(receiptId),
+            mimeType: MCP_AGENT_RECEIPT_RESOURCE_MIME_TYPE,
+            text: JSON.stringify(receipt, null, 2),
+            _meta: {
+                verification: {
+                    valid: true,
+                    message_digest: verified.message_digest_sha256_hex,
+                },
+            },
+        };
+    }
     listTools() {
         return this.tools.map((tool) => ({
             name: tool.name,
@@ -973,6 +1016,10 @@ export class PaybondMCPServer {
                             tools: {
                                 listChanged: false,
                             },
+                            resources: {
+                                subscribe: false,
+                                listChanged: false,
+                            },
                         },
                         serverInfo: {
                             name: SERVER_NAME,
@@ -1002,6 +1049,39 @@ export class PaybondMCPServer {
                         tools: this.listTools(),
                     },
                 };
+            case "resources/list":
+                return {
+                    jsonrpc: "2.0",
+                    id: message.id,
+                    result: {
+                        resources: [],
+                    },
+                };
+            case "resources/templates/list":
+                return {
+                    jsonrpc: "2.0",
+                    id: message.id,
+                    result: {
+                        resourceTemplates: this.listResourceTemplates(),
+                    },
+                };
+            case "resources/read": {
+                const params = ensureObject(message.params, "resources/read params");
+                const uri = stringArg(params.uri, "uri");
+                try {
+                    const contents = await this.readResource(uri);
+                    return {
+                        jsonrpc: "2.0",
+                        id: message.id,
+                        result: {
+                            contents: [contents],
+                        },
+                    };
+                }
+                catch (err) {
+                    return responseError(message.id, -32000, formatError(err));
+                }
+            }
             case "tools/call": {
                 const params = ensureObject(message.params, "tools/call params");
                 const name = stringArg(params.name, "name");

package/dist/mpp-commercial.d.ts

@@ -0,0 +1,19 @@
+/**
+ * MPP commercial denomination helpers for Paybond MVP.
+ *
+ * Paybond intent commercial fields remain USD-denominated (`amount_cents`, `currency`).
+ * Tempo session deposits use USDC base units (6 decimals): `amount_cents * 10_000`.
+ */
+import type { SettlementRail } from "./principal-intent.js";
+/** USDC uses 6 decimal places; one USD cent maps to 10_000 base units. */
+export declare const USDC_BASE_UNITS_PER_USD_CENT = 10000;
+/** Rails that require USD-denominated commercial intent fields for MVP. */
+export declare const USD_DENOMINATED_SETTLEMENT_RAILS: Set<SettlementRail>;
+/**
+ * Rejects non-USD intents on rails that remain USD-denominated for MVP.
+ */
+export declare function validateUsdDenominatedSettlement(settlementRail: SettlementRail, currency: string): void;
+/**
+ * Converts Paybond USD cents to Tempo USDC base units.
+ */
+export declare function usdCentsToUsdcBaseUnits(amountCents: number): bigint;