@paybond/kit 0.11.10 → 0.12.0

package/dist/index.js

@@ -4,14 +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 ?? "");
@@ -81,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";
@@ -467,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;
@@ -477,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) {
@@ -598,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}`, {
@@ -612,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}`);
@@ -634,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,
@@ -684,6 +708,34 @@ export class HarborClient {
             predicatePassed: body.predicate_passed,
         };
     }
+    /**
+     * POST `/intents/{intentId}/settlement/confirm` — confirms the settlement action implied by
+     * stored evidence evaluation (does not choose release vs refund).
+     */
+    async confirmSettlement(intentId, body = {}, options) {
+        const url = `${this.base}intents/${intentId}/settlement/confirm`;
+        const headers = {
+            "content-type": "application/json",
+            "x-tenant-id": this.tenantId,
+        };
+        if (options?.idempotencyKey?.trim()) {
+            headers["idempotency-key"] = options.idempotencyKey.trim();
+        }
+        const res = await this.fetchWithRetries(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+        }, { retryBody: body });
+        const text = await res.text();
+        if (!res.ok) {
+            throw new HarborHttpError(`Harbor settlement confirm HTTP ${res.status}: ${text}`, {
+                statusCode: res.status,
+                url,
+                bodyText: text,
+            });
+        }
+        return JSON.parse(text);
+    }
     /**
      * `GET /ledger/v1/tip` — latest sequence and entry commitment for the authenticated tenant.
      *
@@ -966,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,
@@ -976,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",
         });
     }
@@ -996,6 +1056,18 @@ export class GatewayHarborClient {
         }
         return parseSubmitEvidenceResponse(JSON.parse(text));
     }
+    /** Recognition-gated Gateway Harbor settlement confirmation. */
+    async confirmSettlement(intentId, body, options) {
+        const { res, text, url } = await this.postJSON(`/harbor/intents/${encodeURIComponent(intentId)}/settlement/confirm`, body, this.mutationHeaders("confirmSettlement", options));
+        if (!res.ok) {
+            throw new HarborHttpError(`Gateway Harbor settlement confirm HTTP ${res.status}: ${text}`, {
+                statusCode: res.status,
+                url,
+                bodyText: text,
+            });
+        }
+        return JSON.parse(text);
+    }
 }
 /**
  * Gateway sandbox guardrail helpers.
@@ -1117,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",
@@ -1169,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,
@@ -1318,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"),
@@ -1333,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"),
@@ -2008,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() } : {}),
@@ -2131,7 +2294,8 @@ function nowRfc3339Seconds() {
     return new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
 }
 /**
- * Ergonomic intent helpers: principal-signed intent create, x402 funding, and payee-signed evidence.
+ * Ergonomic intent helpers: principal-signed intent create, x402 funding, payee-signed evidence,
+ * and settlement confirmation.
  */
 export class PaybondIntents {
     harbor;
@@ -2174,10 +2338,78 @@ export class PaybondIntents {
     async fund(params) {
         return this.harbor.fundIntent(params.intentId, {
             paymentSignature: params.paymentSignature,
+            paymentAuthorization: params.paymentAuthorization,
             idempotencyKey: params.idempotencyKey,
             recognitionProof: params.recognitionProof,
         });
     }
+    /**
+     * One-call x402 fund flow: sign 402 challenges, retry with `payment-signature`, and poll until funded.
+     *
+     * Wallet keys stay app-owned — pass injectable `signPayment` and `issueRecognitionProof` callbacks.
+     */
+    async fundWithX402(params) {
+        const { intentId, recognitionProof, signPayment, issueRecognitionProof, pollOptions, idempotencyKey } = params;
+        return executeFundWithX402({
+            intentId,
+            recognitionProof,
+            signPayment,
+            issueRecognitionProof,
+            pollOptions,
+            fund: ({ recognitionProof: proof, paymentSignature }) => this.fund({
+                intentId,
+                recognitionProof: proof,
+                paymentSignature,
+                idempotencyKey,
+            }),
+        });
+    }
+    /**
+     * 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.
      */
@@ -2191,6 +2423,14 @@ export class PaybondIntents {
         });
         return this.harbor.submitEvidence(rest.intentId, wire, { idempotencyKey, recognitionProof });
     }
+    /**
+     * Confirm Harbor settlement through Gateway `POST /harbor/intents/{id}/settlement/confirm`.
+     * Confirms the action implied by stored evidence; does not choose release vs refund.
+     */
+    async confirmSettlement(params) {
+        const { intentId, recognitionProof, body = {}, idempotencyKey } = params;
+        return this.harbor.confirmSettlement(intentId, body, { idempotencyKey, recognitionProof });
+    }
 }
 /**
  * High-level Kit entrypoint: tenant-bound Gateway clients plus ergonomic intent helpers.
@@ -2203,8 +2443,10 @@ export class Paybond {
     a2a;
     protocol;
     intents;
+    audit;
     agentRun;
-    constructor(harbor, guardrails, signal, fraud, a2a, protocol) {
+    agent;
+    constructor(harbor, guardrails, signal, fraud, a2a, protocol, audit) {
         this.harbor = harbor;
         this.guardrails = guardrails;
         this.signal = signal;
@@ -2212,7 +2454,9 @@ export class Paybond {
         this.a2a = a2a;
         this.protocol = protocol;
         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) {
@@ -2243,7 +2487,11 @@ export class Paybond {
             staticGatewayBearerToken: init.apiKey,
             maxRetries,
         });
-        return new Paybond(harbor, guardrails, signal, fraud, a2a, protocol);
+        const audit = new PaybondAudit(PaybondAuditExports.open(gatewayBaseUrl, tenantId, {
+            staticGatewayBearerToken: init.apiKey,
+            maxRetries,
+        }));
+        return new Paybond(harbor, guardrails, signal, fraud, a2a, protocol, audit);
     }
     /** Reserved for future HTTP client cleanup; safe to call after work completes. */
     async aclose() {
@@ -2295,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);
@@ -2325,10 +2566,16 @@ export class Paybond {
 export { normalizeJson, jsonValueDigest } from "./json-digest.js";
 export { buildSignedCreateIntentBody, buildSignedCreateIntentBodyWithPolicyBinding, intentCreationSignBytesRaw, intentCreationSignBytesWithPolicyBinding, } from "./principal-intent.js";
 export { artifactsDigest, evidenceSignBytesV1, signPayeeEvidenceBinding, } from "./payee-evidence.js";
-export { AGENT_RECOGNITION_GATEWAY_VERIFIER_ID, AGENT_RECOGNITION_PROOF_KIND_V1, AGENT_RECOGNITION_PURPOSE_EVIDENCE_SUBMIT, newAgentRecognitionRequestEnvelope, signAgentRecognitionProofV1, signHarborEvidenceSubmitRecognitionProof, } from "./agent-recognition.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";
 export { PaybondAgentRun, PaybondAgentRunBindError, PaybondAgentRunFacade, PaybondEvidenceSubmitError, PaybondToolInterceptor, PaybondToolRegistry, PaybondToolRegistryValidationError, PaybondUnregisteredSideEffectingToolError, buildAutoEvidencePayload, createGenericToolExecutor, createGuardedAgent, createGuardedAgentRunner, createPaybondAgent, createPaybondGenericAgentConfig, createPaybondGenericInputGuard, createPaybondToolRegistry, createToolInputGuardAdapter, instrumentPaybondAgent, instrumentPaybondClaudeAgents, instrumentPaybondLangGraph, instrumentPaybondMCP, instrumentPaybondOpenAI, instrumentPaybondVercel, paybondGenericToolExecutorAdapter, paybondToolInputGuardAdapter, resolveAgentPolicySource, toPaybondAgentResult, wrapPaybondTools, PaybondInstrumentBuilder, PaybondInstrumented, PaybondInstrumentRuntime, PaybondLazyContextError, PaybondUnboundContextError, discoverPolicyFromAgent, discoverToolNames, discoverToolsFromAgent, inlinePolicyToDocument, isInlinePolicy, isInstrumentableAgentObject, readPaybondAgentInstrumentation, } from "./agent/index.js";
+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/init.js

@@ -22,6 +22,9 @@ const AGENT_MIDDLEWARE_FRAMEWORKS = new Set([
     "openai",
     "langgraph",
     "vercel-ai",
+    "mastra",
+    "cloudflare-agents",
+    "mcp",
 ]);
 const AGENT_MIDDLEWARE_FRAMEWORK_ALIASES = {
     "provider-agnostic": "generic",
@@ -31,6 +34,30 @@ const PRESET_DEFAULT_OUT = {
     "paid-tool-guard": "paybond-paid-tool-guard.ts",
     "agent-middleware": "paybond-agent-middleware.ts",
 };
+/** Comment block for production intent create via policy_binding (signing v7). */
+function productionPolicyBindingComments(harborTemplateId) {
+    return `// Production (signing v7): publish managed template head for ${harborTemplateId}, then create a funded intent.
+// import { PaybondPolicy } from "@paybond/kit";
+// const policy = await PaybondPolicy.load("./paybond.policy.yaml");
+// const publishedHead = {
+//   templateId: "<template_id>",
+//   versionSeq: 1,
+//   materializedPredicate: { /* from publish response */ },
+//   policyContentDigestHex: "<digest_hex>",
+// };
+// const intentInput = policy.toIntentCreateInput({
+//   principalDid,
+//   principalSigningSeed: principalSeed32,
+//   payeeDid,
+//   payeeSigningSeed: payeeSeed32,
+//   deadlineRfc3339,
+//   settlementRail: "stripe_connect",
+//   recognitionProof,
+//   publishedPolicyHead: publishedHead,
+// });
+// const created = await paybond.intents.createWithPolicyBinding(intentInput);
+// Fund if needed, then attach middleware: paybond.agentRun.bind({ attach: { intentId, capabilityToken, productionEvidence }, registry })`;
+}
 const FRAMEWORK_NOTES = {
     generic: "Wrap the returned function around any side-effecting tool handler.",
     "provider-agnostic": "Use the guarded handler with OpenAI, Gemini, Claude/Anthropic, local models, or any custom runtime.",
@@ -52,7 +79,7 @@ function usage() {
         "  agent-middleware    PaybondAgentRun + tool registry middleware",
         "",
         "Frameworks (paid-tool-guard): generic|provider-agnostic|openai|claude|anthropic|gemini|google-ai|vercel-ai|langgraph|mcp",
-        "Frameworks (agent-middleware): generic|claude-agents|openai|langgraph|vercel-ai",
+        "Frameworks (agent-middleware): generic|claude-agents|openai|langgraph|vercel-ai|mastra|cloudflare-agents|mcp",
     ].join("\n");
 }
 function normalizeAgentMiddlewareFramework(framework) {
@@ -197,6 +224,24 @@ export async function openPaybondFromEnv(options: OpenPaybondFromEnvOptions = {}
   });
 }`;
 }
+function agentMiddlewareHeaderComments(framework) {
+    const smokeCommands = {
+        generic: 'paybond agent sandbox smoke --operation travel.book_hotel --requested-spend-cents 20000 --evidence-preset cost_and_completion --result-body \'{"reservation":{"status":"confirmed","price_cents":20000}}\'',
+        "claude-agents": "paybond agent demo claude-agents smoke --operation travel.book_hotel --requested-spend-cents 20000 --evidence-preset cost_and_completion --format json",
+        openai: "paybond agent demo openai smoke --operation travel.book_hotel --requested-spend-cents 20000 --evidence-preset cost_and_completion --format json",
+        langgraph: "paybond agent demo langgraph smoke --operation travel.book_hotel --requested-spend-cents 20000 --evidence-preset cost_and_completion --format json",
+        "vercel-ai": "paybond agent demo vercel-ai smoke --operation travel.book_hotel --requested-spend-cents 20000 --evidence-preset cost_and_completion --format json",
+        mastra: "paybond agent demo mastra smoke --operation travel.book_hotel --requested-spend-cents 20000 --evidence-preset cost_and_completion --format json",
+        "cloudflare-agents": "paybond agent demo cloudflare-agents smoke --operation travel.book_hotel --requested-spend-cents 20000 --evidence-preset cost_and_completion --format json",
+        mcp: "paybond agent demo mcp smoke --operation travel.book_hotel --requested-spend-cents 20000 --evidence-preset cost_and_completion --format json",
+    };
+    return [
+        "// Paybond for paid tools; provider-native limits for LLM token caps only.",
+        "// Policy: ./paybond.policy.yaml (scaffold with paybond policy init).",
+        `// Smoke: ${smokeCommands[framework]}`,
+        "// Production: createWithPolicyBinding after publishing the managed template head — see block below.",
+    ].join("\n");
+}
 function agentMiddlewareFrameworkBlock(framework) {
     switch (framework) {
         case "claude-agents":
@@ -326,6 +371,66 @@ export async function runGuardedGenerateText(
     toolApproval: paybondVercelToolApproval(run),
     prompt,
   });
+}`;
+        case "mastra":
+            return `import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+import { createPaybondMastraConfig } from "@paybond/kit/mastra";
+import type { PaybondAgentRun } from "@paybond/kit/agent";
+
+/** Wrap Mastra \`createTool()\` definitions with Paybond middleware on \`execute\`. */
+export function createGuardedMastraTools(run: PaybondAgentRun) {
+  const tools = [
+    createTool({
+      id: "travel.book_hotel",
+      description: "Book a hotel room",
+      inputSchema: z.object({
+        city: z.string(),
+        estimatedPriceCents: z.number().int().nonnegative(),
+      }),
+      execute: async (args) => bookHotel(args),
+    }),
+    createTool({
+      id: "search.web",
+      description: "Search the web",
+      inputSchema: z.object({ query: z.string() }),
+      execute: async (args) => searchWeb(args),
+    }),
+  ];
+  return createPaybondMastraConfig(run, tools).tools;
+}`;
+        case "cloudflare-agents":
+            return `import { tool } from "ai";
+import { z } from "zod";
+import { createPaybondCloudflareAgentsConfig } from "@paybond/kit/cloudflare-agents";
+import type { PaybondAgentRun } from "@paybond/kit/agent";
+
+/** Wrap Cloudflare Agents \`getTools()\` AI SDK tool definitions with Paybond middleware on \`execute\`. */
+export function createGuardedCloudflareAgentTools(run: PaybondAgentRun) {
+  const tools = {
+    "travel.book_hotel": tool({
+      description: "Book a hotel room",
+      inputSchema: z.object({
+        city: z.string(),
+        estimatedPriceCents: z.number().int().nonnegative(),
+      }),
+      execute: async (args) => bookHotel(args),
+    }),
+    searchWeb: tool({
+      description: "Search the web",
+      inputSchema: z.object({ query: z.string() }),
+      execute: async (args) => searchWeb(args),
+    }),
+  };
+  return createPaybondCloudflareAgentsConfig(run, tools);
+}`;
+        case "mcp":
+            return `import { createPaybondMcpToolSurface } from "@paybond/kit/mcp";
+import type { PaybondAgentRun } from "@paybond/kit/agent";
+
+/** Stdio MCP host config — bind a run first, then \`paybond mcp install\` for coding-agent hosts. */
+export function createMcpToolSurface(run: PaybondAgentRun) {
+  return createPaybondMcpToolSurface(run, { envFile: ".env.local" });
 }`;
         default:
             return `import { createPaybondGenericAgentConfig } from "@paybond/kit/agent";
@@ -360,6 +465,8 @@ import {
 
 ${envHelpersBlock()}
 
+${agentMiddlewareHeaderComments(framework)}
+
 // Agent middleware preset maps to completion catalog archetype: cost_and_completion (${completionPreset.harbor_template_id}).
 const COMPLETION_PRESET_ID = "cost_and_completion";
 const DEFAULT_OPERATION = "travel.book_hotel";
@@ -426,6 +533,8 @@ export async function bindAgentRun(
   return paybond.agentRun.bind(bindInput);
 }
 
+${productionPolicyBindingComments(completionPreset.harbor_template_id)}
+
 ${agentMiddlewareFrameworkBlock(framework)}
 `;
 }
@@ -454,12 +563,14 @@ export function buildCompletionEvidence(fields: CompletionEvidence): Record<stri
   return { ...fields };
 }
 
-// Production: use buildSignedCreateIntentBodyWithPolicyBinding from @paybond/kit after publishing ${completionPreset.harbor_template_id}.
 export const policyBindingStub = {
   template_id: HARBOR_TEMPLATE_ID,
   parameters: ${jsonLiteral(completionPreset.parameters, 2)} as const,
+  // version_seq and head_digest are assigned after publishing the managed template head.
 };
 
+${productionPolicyBindingComments(completionPreset.harbor_template_id)}
+
 const DEFAULT_OPERATION = "paid_tool.operation";
 const DEFAULT_REQUESTED_SPEND_CENTS = 500;
 

package/dist/mastra/config.d.ts

@@ -0,0 +1,30 @@
+import type { PaybondAgentRun } from "../agent/run.js";
+/** Minimal Mastra tool shape — matches `createTool()` output without importing `@mastra/core`. */
+export type MastraToolLike = {
+    id: string;
+    description: string;
+    inputSchema?: unknown;
+    outputSchema?: unknown;
+    suspendSchema?: unknown;
+    resumeSchema?: unknown;
+    requestContextSchema?: unknown;
+    execute?: (inputData: unknown, context?: unknown) => unknown | Promise<unknown>;
+};
+/** Mastra runner config: guarded tools with wrapped `execute` handlers. */
+export type PaybondMastraConfig<TTools extends MastraToolLike[]> = {
+    tools: TTools;
+};
+/**
+ * Wrap side-effecting Mastra tools with Paybond `wrapExecute` so Harbor verify,
+ * spend finalize, and auto-evidence run after successful execution.
+ *
+ * Read-only tools pass through unchanged.
+ */
+export declare function paybondMastraWrapTools<TTools extends MastraToolLike[]>(run: PaybondAgentRun, tools: TTools): TTools;
+/**
+ * Framework runner helper for Mastra `createTool({ execute })` definitions.
+ *
+ * Preserves schema, id, and description; replaces `execute` only on
+ * side-effecting registry tools.
+ */
+export declare function createPaybondMastraConfig<TTools extends MastraToolLike[]>(run: PaybondAgentRun, tools: TTools): PaybondMastraConfig<TTools>;