@paybond/kit 0.11.11 → 0.12.0

package/dist/index.js

@@ -4,16 +4,18 @@
  */
 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 { 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 +85,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 +477,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 +487,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 +611,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 +632,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 +655,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,
@@ -996,9 +1018,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 +1032,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 +1189,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 +1241,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 +1393,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 +1411,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 +2097,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() } : {}),
@@ -2217,6 +2338,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 +2364,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,6 +2445,7 @@ export class Paybond {
     intents;
     audit;
     agentRun;
+    agent;
     constructor(harbor, guardrails, signal, fraud, a2a, protocol, audit) {
         this.harbor = harbor;
         this.guardrails = guardrails;
@@ -2287,6 +2456,7 @@ export class Paybond {
         this.intents = new PaybondIntents(harbor);
         this.audit = audit;
         this.agentRun = new PaybondAgentRunFacade(this);
+        this.agent = createPaybondAgentCallable(protocol, (input) => createPaybondAgent(this, input));
     }
     /** Open a tenant-bound hosted Paybond session from a service-account API key. */
     static async open(init) {
@@ -2373,13 +2543,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 +2568,7 @@ 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 { 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 +2576,6 @@ 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_WELL_KNOWN_PATH, actionReceiptId, canonicalAgentReceiptBytes, configHashSha256Hex, promptHashSha256Hex, valueDigestSha256Hex, verifyAgentReceiptV1, } from "./agent-receipt.js";
+export { AGENT_RECEIPT_EXTERNAL_SOURCE_SEP2828, AGENT_RECEIPT_EXTERNAL_SOURCE_X402, partnerRecordDigestSha256Hex, resolveExternalAttestations, sep2828RecordsToExternalAttestations, x402ReceiptToExternalAttestations, } from "./agent-receipt-external-attestations.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,12 @@ 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;
+    }>;
     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,10 @@ 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 { 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.0";
 const MCP_PROTOCOL_VERSION = "2025-11-25";
 const DEFAULT_PRINCIPAL_PATH = "/v1/auth/principal";
 const DEFAULT_RECOGNITION_VERIFIER_ID = "paybond-gateway";
@@ -846,6 +847,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 +913,18 @@ 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);
+        return {
+            uri: agentReceiptResourceUri(receiptId),
+            mimeType: MCP_AGENT_RECEIPT_RESOURCE_MIME_TYPE,
+            text: JSON.stringify(receipt, null, 2),
+        };
+    }
     listTools() {
         return this.tools.map((tool) => ({
             name: tool.name,
@@ -973,6 +1002,10 @@ export class PaybondMCPServer {
                             tools: {
                                 listChanged: false,
                             },
+                            resources: {
+                                subscribe: false,
+                                listChanged: false,
+                            },
                         },
                         serverInfo: {
                             name: SERVER_NAME,
@@ -1002,6 +1035,34 @@ 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");
+                const contents = await this.readResource(uri);
+                return {
+                    jsonrpc: "2.0",
+                    id: message.id,
+                    result: {
+                        contents: [contents],
+                    },
+                };
+            }
             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;

package/dist/mpp-commercial.js

@@ -0,0 +1,34 @@
+/**
+ * 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`.
+ */
+/** USDC uses 6 decimal places; one USD cent maps to 10_000 base units. */
+export const USDC_BASE_UNITS_PER_USD_CENT = 10_000;
+/** Rails that require USD-denominated commercial intent fields for MVP. */
+export const USD_DENOMINATED_SETTLEMENT_RAILS = new Set([
+    "x402_usdc_base",
+    "stripe_ach_debit",
+    "stripe_mpp",
+]);
+/**
+ * Rejects non-USD intents on rails that remain USD-denominated for MVP.
+ */
+export function validateUsdDenominatedSettlement(settlementRail, currency) {
+    if (!USD_DENOMINATED_SETTLEMENT_RAILS.has(settlementRail)) {
+        return;
+    }
+    if (currency.trim().toLowerCase() !== "usd") {
+        throw new Error(`currency must be usd when settlementRail is ${settlementRail} until multi-currency policy is defined`);
+    }
+}
+/**
+ * Converts Paybond USD cents to Tempo USDC base units.
+ */
+export function usdCentsToUsdcBaseUnits(amountCents) {
+    if (!Number.isInteger(amountCents) || amountCents < 0) {
+        throw new Error("amountCents must be a non-negative integer");
+    }
+    return BigInt(amountCents) * BigInt(USDC_BASE_UNITS_PER_USD_CENT);
+}

package/dist/mpp-funding.d.ts

@@ -0,0 +1,71 @@
+import type { AgentRecognitionProofV1, FundIntentResult } from "./index.js";
+import { type FundRequestEnvelope, type X402FundPollOptions } from "./x402-funding.js";
+/** Raw `WWW-Authenticate: Payment …` challenge value from Harbor or the gateway. */
+export type PaymentAuthChallenge = string;
+/** Parsed Payment Auth challenge parameters from a `WWW-Authenticate` header value. */
+export type ParsedPaymentAuthChallenge = {
+    raw: string;
+    id?: string;
+    realm?: string;
+    method?: string;
+    intent?: string;
+    request?: string;
+};
+export type MppFundPollOptions = X402FundPollOptions;
+/** Raised when MPP funding cannot complete (missing challenge, terminal rail status, unexpected HTTP). */
+export declare class PaybondMppFundingFailedError extends Error {
+    readonly intentId: string;
+    readonly lastResult?: FundIntentResult;
+    constructor(message: string, init: {
+        intentId: string;
+        lastResult?: FundIntentResult;
+        cause?: unknown;
+    });
+}
+/** Raised when polling exhausts `maxAttempts` before Harbor returns a funded capability token. */
+export declare class PaybondMppFundingPendingError extends Error {
+    readonly intentId: string;
+    readonly lastResult: FundIntentResult;
+    readonly attempts: number;
+    constructor(message: string, init: {
+        intentId: string;
+        lastResult: FundIntentResult;
+        attempts: number;
+    });
+}
+/**
+ * Parses a `WWW-Authenticate: Payment …` challenge into structured parameters.
+ *
+ * @throws Error when the value is empty or does not start with the Payment scheme.
+ */
+export declare function parsePaymentAuthChallenge(raw: string): ParsedPaymentAuthChallenge;
+/** Selects the Stripe MPP charge challenge from `WWW-Authenticate` values. */
+export declare function selectMppChargeChallenge(wwwAuthenticate: string[] | undefined): PaymentAuthChallenge;
+/** Selects the Tempo MPP session challenge from `WWW-Authenticate` values. */
+export declare function selectMppSessionChallenge(wwwAuthenticate: string[] | undefined): PaymentAuthChallenge;
+/** Canonical `/fund` request envelope for Gateway `POST /harbor/intents/{intentId}/fund`. */
+export declare function buildMppFundRequestEnvelope(intentId: string): FundRequestEnvelope;
+export type ExecuteFundWithMppParams = {
+    intentId: string;
+    recognitionProof: AgentRecognitionProofV1 | Record<string, unknown>;
+    /** App-owned callback that turns a Payment Auth challenge into a credential token or header value. */
+    createPaymentCredential: (challenge: PaymentAuthChallenge) => Promise<string>;
+    issueRecognitionProof: (envelope: FundRequestEnvelope) => Promise<AgentRecognitionProofV1 | Record<string, unknown>>;
+    pollOptions?: MppFundPollOptions;
+    selectChallenge: (wwwAuthenticate: string[] | undefined) => PaymentAuthChallenge;
+    fund: (args: {
+        recognitionProof: AgentRecognitionProofV1 | Record<string, unknown>;
+        paymentAuthorization?: string;
+    }) => Promise<FundIntentResult>;
+};
+/**
+ * Orchestrate MPP `/fund`: handle 402 Payment Auth challenges, retry with credentials, poll until funded.
+ *
+ * Wallet and SPT secrets stay app-owned — pass injectable `createPaymentCredential` and
+ * `issueRecognitionProof` callbacks; Paybond never stores MPP signing material.
+ */
+export declare function executeFundWithMpp(params: ExecuteFundWithMppParams): Promise<FundIntentResult>;
+/** One-shot Stripe MPP charge funding through Payment Auth semantics. */
+export declare function executeFundWithMppCharge(params: Omit<ExecuteFundWithMppParams, "selectChallenge">): Promise<FundIntentResult>;
+/** Tempo MPP session funding through Payment Auth semantics. */
+export declare function executeFundWithMppSession(params: Omit<ExecuteFundWithMppParams, "selectChallenge">): Promise<FundIntentResult>;