@atlasauth/pca-a2a 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Atlas Authorization
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,64 @@
-# Temporary Holding Version
+# @atlasauth/pca-a2a
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A2A (Agent2Agent) adapter for Proof-Carrying Authority (PCA). A2A defines how agents discover each other and exchange tasks; it does not prove that a relayed request is authorized by the principal behind it. This package binds PCA proofs onto three A2A surfaces, failing closed throughout:
+
+1. **Proof-carrying tasks** - attach a PCActn (a signed single-action proof with its capability chain) to a Task or Message under a namespaced `metadata` key, and verify it on receipt.
+2. **Signed Agent Cards** - issue and validate an A2A `AgentCardSignature` (a detached JWS, via `jose`) whose protected header commits to the agent's PCA passport id.
+3. **AP2 payment profile** - map a PCActn to an AP2-shaped Payment Mandate that carries its authority by reference to the proof.
+
+## Install
+
+```sh
+npm i @atlasauth/pca-a2a
+```
+
+Depends on `@atlasauth/pca` and `jose` (installed transitively). For the full AP2 Intent/Cart/Payment chain and settlement hooks, see `@atlasauth/pca-ap2`.
+
+## Usage
+
+```ts
+import { buildPCActn } from '@atlasauth/pca';
+import {
+  attachPcaToA2ATask, pcaA2AMiddleware,
+  issueSignedAgentCard, verifyAgentCard,
+  a2aPaymentMandateFromPca, verifyA2APaymentMandate,
+} from '@atlasauth/pca-a2a';
+
+// Sender: build a PCActn with @atlasauth/pca, then ride it on the task.
+const pcActn = buildPCActn({ grant, chain: [grant], plan, nodeId: 'buy-1', counter: 1,
+                             signerSecret: agentSecret, aud: 'my-rs' });
+const task = attachPcaToA2ATask({ id: 't1', status: { state: 'submitted' } }, pcActn);
+
+// Receiver: guard incoming tasks. Pin the principal you trust.
+const guard = pcaA2AMiddleware({ aud: 'my-rs', expectedRootIssuer: principalPublicKey });
+const verdict = await guard(task);       // { ok: true, result, pcActn } | { ok: false, reason }
+
+// Signed Agent Card (key is a jose KeyLike, Uint8Array or JWK).
+const card = await issueSignedAgentCard({ name: 'Buyer', url: 'https://a.example' }, privateKey,
+                                        { passport: { id: 'pp_1' } });
+await verifyAgentCard(card, { key: publicKey });  // { ok: true, passportRef: 'pp_1', ... }
+
+// Payment mandate that points at the PCActn.
+const mandate = a2aPaymentMandateFromPca(pcActn, {
+  amount: { currency: 'USD', value: 120 }, paymentMethod: { type: 'card' }, merchant: 'acme',
+});
+await verifyA2APaymentMandate(mandate, pcActn, { aud: 'my-rs', expectedRootIssuer: principalPublicKey });
+```
+
+By default a guard requires a proof (`require: true`); with `require: false` a task without a proof passes, but a proof that is present and invalid is still rejected. Always pin `expectedRootIssuer` (or `grant`): otherwise the chain root is taken from the proof itself and only proves internal consistency, not that a principal you trust issued it.
+
+## API
+
+- Tasks: `attachPcaToA2ATask`, `attachPcaToA2AMessage`, `extractPca`, `extractPcaFromMessage`, `verifyA2ATask`, `pcaA2AMiddleware`, `PCA_A2A_EXTENSION_URI`.
+- Agent Cards: `issueSignedAgentCard`, `verifyAgentCard` (verify with a single `key` or a `jwks`).
+- Payments: `a2aPaymentMandateFromPca`, `pcaBindingFromA2APaymentMandate`, `verifyA2APaymentMandate`, `A2A_AP2_CONTEXT`.
+
+## Status
+
+Experimental. The A2A object model here is structural and permissive, not a full A2A SDK. The Payment Mandate shape follows the AP2 vocabulary but its JSON-LD context is a placeholder and PCA-specific fields live in a non-standard `x_pca` extension; validate against the official AP2 schemas before production use. The cryptography is unaudited.
+
+Source and issues: https://github.com/Atlas-Authorization/pca
+
+## License
+
+MIT - see LICENSE

package/dist/index.d.ts

@@ -0,0 +1,288 @@
+/**
+ * @atlasauth/pca-a2a — A2A (Agent2Agent) adapter for PCA.
+ *
+ * ┌──────────────────────────────────────────────────────────────────────────────────────────────┐
+ * │  PCA GOVERNS. A2A is the agent-to-agent delegation + task wire. AP2 carries the payment mandate. │
+ * └──────────────────────────────────────────────────────────────────────────────────────────────┘
+ *
+ * A2A (Agent2Agent — originated at Google, donated to the Linux Foundation; v1.0 GA Apr 2026) is the
+ * open protocol for how autonomous agents discover one another (the Agent Card at
+ * `/.well-known/agent-card.json`), hand each other work (Tasks carrying Messages), and settle payment
+ * (the AP2 payment profile). A2A says HOW agents talk; it does not, on its own, prove that a request an
+ * agent relays is actually AUTHORIZED by the principal behind it. That is exactly the gap PCA closes.
+ *
+ * This adapter binds PCA's proof-carrying authority onto A2A's three surfaces, FAIL-CLOSED throughout:
+ *
+ *   1. Proof-carrying A2A Tasks — a PCActn (a signed, single-action proof of authority with its
+ *      attenuating capability chain) rides on a Task's metadata. A receiving agent re-verifies it before
+ *      acting, so a relayed task cannot exceed what the principal actually delegated.
+ *   2. Signed Agent Cards — an A2A Agent Card is validated against an `AgentCardSignature` (a JWS over
+ *      the card, per A2A 1.0) via `jose`, and an issued card embeds a reference to the agent's PCA
+ *      passport, so the card points at verifiable proof-of-authority instead of being a self-declaration.
+ *   3. AP2 payment profile — a PCActn maps to an AP2 Payment Mandate whose authority is carried by
+ *      reference to the proof (the mandate is PCA-verifiable: resolve the referenced PCActn and verify it).
+ *
+ * The full AP2 Intent→Cart→Payment VDC chain, its non-amplifying-narrowing verifier and the settlement
+ * rails live in `@atlasauth/pca-ap2`; this module does NOT duplicate them. It emits only the single
+ * Payment-Mandate profile an A2A payment Task needs, using the SAME field vocabulary (`amount`,
+ * `payment_method`, `human_present`, `merchant`, namespaced `x_pca`) so the two stay wire-compatible.
+ * When `@atlasauth/pca-ap2` is on the dependency path, prefer composing with its full chain + settlement
+ * backends and treat this profile as the A2A-task envelope around a verified PCActn.
+ */
+import { type Capability, type PCActn, type VerifyResult } from '@atlasauth/pca';
+import { type JSONWebKeySet, type JWK, type KeyLike } from 'jose';
+/**
+ * The URI-namespaced A2A extension key a PCActn rides under on a Task's / Message's `metadata`. A2A
+ * extensions are identified by URI and carried in `metadata`, so a non-PCA-aware peer simply ignores it.
+ */
+export declare const PCA_A2A_EXTENSION_URI: "https://atlasauth.net/a2a/ext/pca/v2";
+/** An A2A message part (text / file / data). Structural only; `kind` discriminates in the wild. */
+export interface A2APart {
+    kind: string;
+    [k: string]: unknown;
+}
+/** An A2A Message — a turn exchanged within a Task. */
+export interface A2AMessage {
+    role: 'user' | 'agent';
+    parts: A2APart[];
+    messageId?: string;
+    kind?: 'message';
+    taskId?: string;
+    contextId?: string;
+    metadata?: Record<string, unknown>;
+}
+/** An A2A Task status. */
+export interface A2ATaskStatus {
+    state: string;
+    message?: A2AMessage;
+    timestamp?: string;
+}
+/** An A2A Task — the unit of work one agent hands another. */
+export interface A2ATask {
+    id: string;
+    contextId?: string;
+    kind?: 'task';
+    status: A2ATaskStatus;
+    history?: A2AMessage[];
+    metadata?: Record<string, unknown>;
+}
+/** Attach a PCActn to a Task (returns a copy; the input is not mutated). */
+export declare function attachPcaToA2ATask(task: A2ATask, pcActn: PCActn): A2ATask;
+/** Attach a PCActn to a single Message (returns a copy; the input is not mutated). */
+export declare function attachPcaToA2AMessage(message: A2AMessage, pcActn: PCActn): A2AMessage;
+/**
+ * Extract the PCActn carried on a Task. Looks, in order, at the Task metadata, the current
+ * `status.message` metadata, then the most recent history message's metadata. Returns `undefined`
+ * when no well-formed proof is present (the verify step then fails closed).
+ */
+export declare function extractPca(task: A2ATask): PCActn | undefined;
+/** Extract the PCActn carried on a single Message (fail-closed). */
+export declare function extractPcaFromMessage(message: A2AMessage): PCActn | undefined;
+/** Options shared by every PCActn verification surface in this module. */
+export interface PcaVerifyOptions {
+    /** This resource server / Atlas instance id. Compared against the PCActn's signed `aud` (fail-closed). */
+    aud: string;
+    /** Verification clock (epoch ms). Default `Date.now()`. */
+    now?: number;
+    /**
+     * The trusted root grant (capability). When omitted, the grant is taken from the embedded chain root
+     * (`cap_chain[0]`); the full chain cryptography is still verified either way, but pinning `grant` (or
+     * `expectedRootIssuer`) is what ties the proof to a KNOWN principal rather than whatever the chain claims.
+     */
+    grant?: Capability;
+    /** When set, the chain root's issuer MUST equal this principal key (b64u), else verification fails. */
+    expectedRootIssuer?: string;
+}
+/** The result of verifying a proof-carrying A2A artifact. */
+export interface A2AVerification {
+    ok: boolean;
+    reason?: string;
+    /** The underlying PCA core verification result (present once a PCActn was found and evaluated). */
+    result?: VerifyResult;
+    /** The extracted PCActn (present when one was carried). */
+    pcActn?: PCActn;
+}
+/**
+ * Verify the proof-carrying action on an A2A Task. Fail-closed: a Task with no attached PCActn, or one
+ * whose PCActn does not verify (bad signature, wrong audience, expired, out-of-plan, tampered chain …),
+ * is rejected.
+ */
+export declare function verifyA2ATask(task: A2ATask, opts: PcaVerifyOptions): Promise<A2AVerification>;
+/** Configuration for the server-side A2A guard. */
+export interface PcaA2AMiddlewareOptions extends PcaVerifyOptions {
+    /**
+     * When `true` (the default), a Task MUST carry a valid PCActn or it is rejected. When `false`, a Task
+     * with NO proof is allowed through — but a Task that DOES carry a proof must still verify (a present
+     * but invalid/tampered proof is always rejected; this guard never fails open on tampering).
+     */
+    require?: boolean;
+}
+/** The per-Task guard returned by {@link pcaA2AMiddleware}. */
+export type PcaA2AGuard = (task: A2ATask) => Promise<A2AVerification>;
+/**
+ * Build a server guard that verifies the proof-carrying action on each incoming A2A Task and rejects
+ * unauthorized ones. Framework-agnostic: wire the returned function into your JSON-RPC `message/send` /
+ * `tasks/send` handler and reject when `ok` is false.
+ */
+export declare function pcaA2AMiddleware(opts: PcaA2AMiddlewareOptions): PcaA2AGuard;
+/** A reference to the agent's PCA passport (see `@atlasauth/pca` `AgentPassport`). */
+export interface A2APassportRef {
+    /** The content-addressed passport id (`AgentPassport.id`). */
+    id: string;
+    /** Optional URL where the full, verifiable passport can be resolved. */
+    uri?: string;
+}
+/**
+ * An A2A Agent Card signature: a detached JWS (JWS JSON serialization) over the canonicalized card with
+ * its `signatures` removed, per A2A 1.0. `protected` is the base64url JWS protected header; `signature`
+ * is the base64url signature. The payload is detached (recomputed from the card on verify).
+ */
+export interface AgentCardSignature {
+    protected: string;
+    signature: string;
+    header?: Record<string, unknown>;
+}
+/** A minimal, permissive A2A Agent Card. Real cards carry many more fields; all are preserved + signed. */
+export interface AgentCard {
+    name: string;
+    description?: string;
+    url?: string;
+    version?: string;
+    /** The PCA passport this card's authority is rooted in (embedded + signed by {@link issueSignedAgentCard}). */
+    pcaPassport?: A2APassportRef;
+    signatures?: AgentCardSignature[];
+    [k: string]: unknown;
+}
+/** A key usable to verify a card signature. A plain JWK is imported; other forms are passed through. */
+export type VerifyKeyInput = KeyLike | Uint8Array | JWK;
+/** A key usable to sign a card. A plain JWK is imported; other forms are passed through. */
+export type SignKeyInput = KeyLike | Uint8Array | JWK;
+export interface IssueAgentCardOptions {
+    /** JWS algorithm for the signature. Default `'EdDSA'`. */
+    alg?: string;
+    /** The PCA passport reference to embed so the card points at verifiable proof-of-authority. */
+    passport?: A2APassportRef | {
+        id: string;
+    };
+    /** Optional JWS `kid` (set it when verifiers resolve the key from a JWKS). */
+    kid?: string;
+}
+/**
+ * Issue a signed A2A Agent Card. Embeds the PCA passport reference into the card (`pcaPassport`) AND into
+ * the signed JWS protected header, then signs the canonicalized card (minus `signatures`) with `jose`,
+ * appending the detached-payload `AgentCardSignature`. Because the passport reference is covered by the
+ * signature, the card is a verifiable pointer to proof-of-authority — not a self-declaration.
+ */
+export declare function issueSignedAgentCard(card: AgentCard, signingKey: SignKeyInput, opts?: IssueAgentCardOptions): Promise<AgentCard>;
+export interface VerifyAgentCardOptions {
+    /** A JWKS to resolve the signing key from (matched by the JWS `kid` / `alg`). */
+    jwks?: JSONWebKeySet;
+    /** A single verification key (JWK, raw secret, or a crypto key). */
+    key?: VerifyKeyInput;
+    /** Expected JWS algorithm for `importJWK` of a plain JWK `key` (default `'EdDSA'`). */
+    alg?: string;
+}
+/** The outcome of validating a signed Agent Card. */
+export interface AgentCardVerification {
+    ok: boolean;
+    reason?: string;
+    /** The passport id recovered from a verified signature's protected header (proof-of-authority pointer). */
+    passportRef?: string;
+    /** The passport reference embedded in the (verified) card body, when present. */
+    passport?: A2APassportRef;
+}
+/**
+ * Validate an A2A Agent Card against its `AgentCardSignature`(s). Fail-closed: a card with no signatures,
+ * an unresolvable key, or ANY signature that does not verify is rejected. Every present signature must
+ * verify over the canonicalized card (minus `signatures`). On success, returns the PCA passport id the
+ * signature commits to so a caller can resolve + check it against a `PassportRegistry`.
+ */
+export declare function verifyAgentCard(card: AgentCard, opts: VerifyAgentCardOptions): Promise<AgentCardVerification>;
+/**
+ * JSON-LD contexts for the AP2 VDC envelope — the SAME values `@atlasauth/pca-ap2` uses, so this profile
+ * is wire-compatible with the full AP2 chain. The second entry is a placeholder for the canonical AP2
+ * context URL (replace before production).
+ */
+export declare const A2A_AP2_CONTEXT: readonly string[];
+/** ISO-4217 currency + decimal value (use minor units in production to avoid float drift). */
+export interface A2AMonetaryAmount {
+    currency: string;
+    value: number;
+}
+/** The payment instrument an AP2 Payment Mandate authorizes (never a raw PAN). */
+export interface A2APaymentMethod {
+    type: string;
+    display?: string;
+    token?: string;
+}
+/**
+ * The PCA-native binding carried inside the Payment Mandate's `x_pca` extension. It makes the mandate
+ * PCA-VERIFIABLE: a verifier resolves `pcactn_digest` to the referenced PCActn and verifies that proof,
+ * rather than trusting the mandate on its own. NON-STANDARD by construction (namespaced `x_pca`).
+ */
+export interface PcaPaymentBinding {
+    /** `pcactnDigest()` of the PCActn whose authority backs this mandate. */
+    pcactn_digest: string;
+    /** The resource server / instance the backing PCActn is audience-bound to. */
+    aud: string;
+    /** The backing action's verb / resource / params digest (from the PCActn's committed plan node). */
+    verb: string;
+    resource: string;
+    params_digest: string;
+    /** The grant the backing PCActn's chain is rooted at. */
+    grant_ref: string;
+    /** The acting (leaf) holder key, b64u — the agent the authority was ultimately delegated to. */
+    leaf_holder: string;
+}
+/** AP2 Payment Mandate contents (credentialSubject). Mirrors `@atlasauth/pca-ap2`'s field vocabulary. */
+export interface A2APaymentMandateContents {
+    amount: A2AMonetaryAmount;
+    payment_method: A2APaymentMethod;
+    /**
+     * The AP2 human-present modality. MAPPING: a PCActn carrying a risk-adaptive `threshold` (a
+     * guardian/principal co-signature) ⇒ `human_present = true`; an agent-only (t=1) action ⇒ `false`.
+     * Override explicitly via `humanPresent`.
+     */
+    human_present: boolean;
+    merchant?: string;
+    /** The PCA-verifiable backreference (see {@link PcaPaymentBinding}). */
+    x_pca: PcaPaymentBinding;
+}
+/** An AP2 Payment Mandate VDC carrying a PCA-verifiable backreference. */
+export interface A2APaymentMandate {
+    '@context': readonly string[];
+    type: readonly ['VerifiableCredential', 'PaymentMandate'];
+    /** Issuer (payer / acting agent) public key, b64u. Defaults to the PCActn's leaf holder. */
+    issuer: string;
+    issuanceDate: string;
+    credentialSubject: A2APaymentMandateContents;
+}
+export interface PaymentMandateOptions {
+    /** The amount to authorize. */
+    amount: A2AMonetaryAmount;
+    /** The payment instrument. */
+    paymentMethod: A2APaymentMethod;
+    /** The merchant, if constrained. */
+    merchant?: string;
+    /** Override the human-present modality (else derived from whether the PCActn carries a `threshold`). */
+    humanPresent?: boolean;
+    /** Override the VDC issuer (defaults to the PCActn's leaf holder key). */
+    issuerPublic?: string;
+    /** Issuance clock (epoch ms). Default `Date.now()`. */
+    now?: number;
+}
+/**
+ * Map a PCA proof (a PCActn) to an AP2 Payment Mandate so an A2A payment Task can carry it. The mandate's
+ * authority is carried BY REFERENCE: `x_pca.pcactn_digest` binds it to the PCActn, and the mandate is
+ * verified by resolving + verifying that proof (see {@link verifyA2APaymentMandate}).
+ */
+export declare function a2aPaymentMandateFromPca(pcActn: PCActn, opts: PaymentMandateOptions): A2APaymentMandate;
+/** Read the PCA binding back out of an AP2 Payment Mandate (the round-trip of `x_pca`). */
+export declare function pcaBindingFromA2APaymentMandate(mandate: A2APaymentMandate): PcaPaymentBinding;
+/**
+ * Verify an AP2 Payment Mandate against the PCActn it references. Fail-closed: the mandate's
+ * `x_pca.pcactn_digest` MUST equal `pcactnDigest(pcActn)` (so the mandate is bound to THIS proof), and
+ * the PCActn itself must verify (signature, audience, validity, chain, plan inclusion). This is what makes
+ * the AP2 payment mandate PCA-verifiable rather than a bare assertion.
+ */
+export declare function verifyA2APaymentMandate(mandate: A2APaymentMandate, pcActn: PCActn, opts: PcaVerifyOptions): Promise<A2AVerification>;

package/dist/index.js

@@ -0,0 +1,325 @@
+"use strict";
+/**
+ * @atlasauth/pca-a2a — A2A (Agent2Agent) adapter for PCA.
+ *
+ * ┌──────────────────────────────────────────────────────────────────────────────────────────────┐
+ * │  PCA GOVERNS. A2A is the agent-to-agent delegation + task wire. AP2 carries the payment mandate. │
+ * └──────────────────────────────────────────────────────────────────────────────────────────────┘
+ *
+ * A2A (Agent2Agent — originated at Google, donated to the Linux Foundation; v1.0 GA Apr 2026) is the
+ * open protocol for how autonomous agents discover one another (the Agent Card at
+ * `/.well-known/agent-card.json`), hand each other work (Tasks carrying Messages), and settle payment
+ * (the AP2 payment profile). A2A says HOW agents talk; it does not, on its own, prove that a request an
+ * agent relays is actually AUTHORIZED by the principal behind it. That is exactly the gap PCA closes.
+ *
+ * This adapter binds PCA's proof-carrying authority onto A2A's three surfaces, FAIL-CLOSED throughout:
+ *
+ *   1. Proof-carrying A2A Tasks — a PCActn (a signed, single-action proof of authority with its
+ *      attenuating capability chain) rides on a Task's metadata. A receiving agent re-verifies it before
+ *      acting, so a relayed task cannot exceed what the principal actually delegated.
+ *   2. Signed Agent Cards — an A2A Agent Card is validated against an `AgentCardSignature` (a JWS over
+ *      the card, per A2A 1.0) via `jose`, and an issued card embeds a reference to the agent's PCA
+ *      passport, so the card points at verifiable proof-of-authority instead of being a self-declaration.
+ *   3. AP2 payment profile — a PCActn maps to an AP2 Payment Mandate whose authority is carried by
+ *      reference to the proof (the mandate is PCA-verifiable: resolve the referenced PCActn and verify it).
+ *
+ * The full AP2 Intent→Cart→Payment VDC chain, its non-amplifying-narrowing verifier and the settlement
+ * rails live in `@atlasauth/pca-ap2`; this module does NOT duplicate them. It emits only the single
+ * Payment-Mandate profile an A2A payment Task needs, using the SAME field vocabulary (`amount`,
+ * `payment_method`, `human_present`, `merchant`, namespaced `x_pca`) so the two stay wire-compatible.
+ * When `@atlasauth/pca-ap2` is on the dependency path, prefer composing with its full chain + settlement
+ * backends and treat this profile as the A2A-task envelope around a verified PCActn.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.A2A_AP2_CONTEXT = exports.PCA_A2A_EXTENSION_URI = void 0;
+exports.attachPcaToA2ATask = attachPcaToA2ATask;
+exports.attachPcaToA2AMessage = attachPcaToA2AMessage;
+exports.extractPca = extractPca;
+exports.extractPcaFromMessage = extractPcaFromMessage;
+exports.verifyA2ATask = verifyA2ATask;
+exports.pcaA2AMiddleware = pcaA2AMiddleware;
+exports.issueSignedAgentCard = issueSignedAgentCard;
+exports.verifyAgentCard = verifyAgentCard;
+exports.a2aPaymentMandateFromPca = a2aPaymentMandateFromPca;
+exports.pcaBindingFromA2APaymentMandate = pcaBindingFromA2APaymentMandate;
+exports.verifyA2APaymentMandate = verifyA2APaymentMandate;
+const pca_1 = require("@atlasauth/pca");
+const jose_1 = require("jose");
+// ===================================================================================================
+// Extension identifier
+// ===================================================================================================
+/**
+ * The URI-namespaced A2A extension key a PCActn rides under on a Task's / Message's `metadata`. A2A
+ * extensions are identified by URI and carried in `metadata`, so a non-PCA-aware peer simply ignores it.
+ */
+exports.PCA_A2A_EXTENSION_URI = 'https://atlasauth.net/a2a/ext/pca/v2';
+// ===================================================================================================
+// 1. Proof-carrying A2A Tasks
+// ===================================================================================================
+function withPca(metadata, pcActn) {
+    return { ...(metadata ?? {}), [exports.PCA_A2A_EXTENSION_URI]: pcActn };
+}
+/** Read a PCActn out of a metadata bag (fail-closed: a missing / non-object value yields `undefined`). */
+function readPca(metadata) {
+    if (!metadata)
+        return undefined;
+    const v = metadata[exports.PCA_A2A_EXTENSION_URI];
+    if (v !== null && typeof v === 'object' && !Array.isArray(v))
+        return v;
+    return undefined;
+}
+/** Attach a PCActn to a Task (returns a copy; the input is not mutated). */
+function attachPcaToA2ATask(task, pcActn) {
+    return { ...task, metadata: withPca(task.metadata, pcActn) };
+}
+/** Attach a PCActn to a single Message (returns a copy; the input is not mutated). */
+function attachPcaToA2AMessage(message, pcActn) {
+    return { ...message, metadata: withPca(message.metadata, pcActn) };
+}
+/**
+ * Extract the PCActn carried on a Task. Looks, in order, at the Task metadata, the current
+ * `status.message` metadata, then the most recent history message's metadata. Returns `undefined`
+ * when no well-formed proof is present (the verify step then fails closed).
+ */
+function extractPca(task) {
+    const onTask = readPca(task.metadata);
+    if (onTask)
+        return onTask;
+    const onStatus = readPca(task.status.message?.metadata);
+    if (onStatus)
+        return onStatus;
+    const history = task.history;
+    if (history && history.length > 0) {
+        for (let i = history.length - 1; i >= 0; i--) {
+            const m = history[i];
+            const onMsg = readPca(m?.metadata);
+            if (onMsg)
+                return onMsg;
+        }
+    }
+    return undefined;
+}
+/** Extract the PCActn carried on a single Message (fail-closed). */
+function extractPcaFromMessage(message) {
+    return readPca(message.metadata);
+}
+function chainRoot(chain) {
+    if (!Array.isArray(chain) || chain.length === 0)
+        return undefined;
+    return chain[0];
+}
+/** Core PCActn verification shared by the Task and payment-mandate surfaces. Fail-closed. */
+async function verifyPcActn(pcActn, opts) {
+    const root = chainRoot(pcActn.cap_chain);
+    if (!root)
+        return { ok: false, reason: 'PCActn carries no capability chain', pcActn };
+    if (opts.expectedRootIssuer !== undefined && root.issuer !== opts.expectedRootIssuer) {
+        return {
+            ok: false,
+            reason: 'chain root issuer does not match the expected principal',
+            pcActn,
+        };
+    }
+    const grant = opts.grant ?? root;
+    const result = await (0, pca_1.verifyPCActnCore)(pcActn, {
+        grant,
+        audience: opts.aud,
+        ...(opts.now !== undefined ? { nowEpoch: opts.now } : {}),
+    });
+    return result.allow
+        ? { ok: true, result, pcActn }
+        : { ok: false, reason: result.reason ?? 'PCActn verification failed', result, pcActn };
+}
+/**
+ * Verify the proof-carrying action on an A2A Task. Fail-closed: a Task with no attached PCActn, or one
+ * whose PCActn does not verify (bad signature, wrong audience, expired, out-of-plan, tampered chain …),
+ * is rejected.
+ */
+async function verifyA2ATask(task, opts) {
+    const pcActn = extractPca(task);
+    if (!pcActn)
+        return { ok: false, reason: 'no proof-carrying action attached to this task' };
+    return verifyPcActn(pcActn, opts);
+}
+/**
+ * Build a server guard that verifies the proof-carrying action on each incoming A2A Task and rejects
+ * unauthorized ones. Framework-agnostic: wire the returned function into your JSON-RPC `message/send` /
+ * `tasks/send` handler and reject when `ok` is false.
+ */
+function pcaA2AMiddleware(opts) {
+    const require = opts.require ?? true;
+    return async (task) => {
+        const pcActn = extractPca(task);
+        if (!pcActn) {
+            return require
+                ? { ok: false, reason: 'proof-carrying action required but none attached to task' }
+                : { ok: true };
+        }
+        return verifyPcActn(pcActn, opts);
+    };
+}
+const PCA_PASSPORT_HEADER = 'pca_passport';
+function isJwk(k) {
+    return typeof k === 'object' && k !== null && !(k instanceof Uint8Array) && 'kty' in k;
+}
+/** The canonical bytes a card signature covers: the card with `signatures` removed (everything else kept). */
+function cardSigningBytes(card) {
+    const { signatures: _signatures, ...rest } = card;
+    void _signatures;
+    return (0, pca_1.canonicalBytes)(rest);
+}
+/**
+ * Issue a signed A2A Agent Card. Embeds the PCA passport reference into the card (`pcaPassport`) AND into
+ * the signed JWS protected header, then signs the canonicalized card (minus `signatures`) with `jose`,
+ * appending the detached-payload `AgentCardSignature`. Because the passport reference is covered by the
+ * signature, the card is a verifiable pointer to proof-of-authority — not a self-declaration.
+ */
+async function issueSignedAgentCard(card, signingKey, opts = {}) {
+    const alg = opts.alg ?? 'EdDSA';
+    const passport = opts.passport
+        ? { id: opts.passport.id, ...('uri' in opts.passport && opts.passport.uri !== undefined ? { uri: opts.passport.uri } : {}) }
+        : card.pcaPassport;
+    // Embed the passport reference BEFORE signing so the signature covers it.
+    const toSign = { ...card, ...(passport ? { pcaPassport: passport } : {}) };
+    const payload = cardSigningBytes(toSign);
+    const key = isJwk(signingKey) ? await (0, jose_1.importJWK)(signingKey, alg) : signingKey;
+    const protectedHeader = {
+        alg,
+        b64: false,
+        crit: ['b64'],
+        ...(opts.kid !== undefined ? { kid: opts.kid } : {}),
+        ...(passport ? { [PCA_PASSPORT_HEADER]: passport.id } : {}),
+    };
+    const jws = await new jose_1.FlattenedSign(payload).setProtectedHeader(protectedHeader).sign(key);
+    if (jws.protected === undefined)
+        throw new Error('issueSignedAgentCard: JWS is missing its protected header');
+    const signature = { protected: jws.protected, signature: jws.signature };
+    const existing = toSign.signatures ?? [];
+    return { ...toSign, signatures: [...existing, signature] };
+}
+/**
+ * Validate an A2A Agent Card against its `AgentCardSignature`(s). Fail-closed: a card with no signatures,
+ * an unresolvable key, or ANY signature that does not verify is rejected. Every present signature must
+ * verify over the canonicalized card (minus `signatures`). On success, returns the PCA passport id the
+ * signature commits to so a caller can resolve + check it against a `PassportRegistry`.
+ */
+async function verifyAgentCard(card, opts) {
+    const signatures = card.signatures;
+    if (!Array.isArray(signatures) || signatures.length === 0) {
+        return { ok: false, reason: 'agent card carries no signatures' };
+    }
+    let resolver;
+    try {
+        if (opts.jwks) {
+            resolver = (0, jose_1.createLocalJWKSet)(opts.jwks);
+        }
+        else if (opts.key !== undefined) {
+            resolver = isJwk(opts.key) ? await (0, jose_1.importJWK)(opts.key, opts.alg ?? 'EdDSA') : opts.key;
+        }
+        else {
+            return { ok: false, reason: 'no verification key or JWKS supplied' };
+        }
+    }
+    catch (e) {
+        return { ok: false, reason: `could not resolve verification key: ${e.message}` };
+    }
+    const payload = cardSigningBytes(card);
+    let passportRef;
+    for (let i = 0; i < signatures.length; i++) {
+        const sig = signatures[i];
+        if (!sig || typeof sig.protected !== 'string' || typeof sig.signature !== 'string') {
+            return { ok: false, reason: `signature ${i} is malformed` };
+        }
+        const input = { protected: sig.protected, payload, signature: sig.signature };
+        try {
+            // Split the call so each branch matches a single flattenedVerify overload (key vs. key-resolver).
+            const verified = typeof resolver === 'function'
+                ? await (0, jose_1.flattenedVerify)(input, resolver)
+                : await (0, jose_1.flattenedVerify)(input, resolver);
+            const ref = verified.protectedHeader?.[PCA_PASSPORT_HEADER];
+            if (typeof ref === 'string' && passportRef === undefined)
+                passportRef = ref;
+        }
+        catch (e) {
+            return { ok: false, reason: `signature ${i} did not verify: ${e.message}` };
+        }
+    }
+    return {
+        ok: true,
+        ...(passportRef !== undefined ? { passportRef } : {}),
+        ...(card.pcaPassport ? { passport: card.pcaPassport } : {}),
+    };
+}
+// ===================================================================================================
+// 3. AP2 payment profile (the A2A payment-Task envelope — PCA-verifiable by reference)
+// ===================================================================================================
+/**
+ * JSON-LD contexts for the AP2 VDC envelope — the SAME values `@atlasauth/pca-ap2` uses, so this profile
+ * is wire-compatible with the full AP2 chain. The second entry is a placeholder for the canonical AP2
+ * context URL (replace before production).
+ */
+exports.A2A_AP2_CONTEXT = [
+    'https://www.w3.org/2018/credentials/v1',
+    'https://ap2-protocol.org/context/v0.2',
+];
+function leafHolderOf(chain) {
+    if (!Array.isArray(chain) || chain.length === 0)
+        return undefined;
+    const leaf = chain[chain.length - 1];
+    return leaf?.holder;
+}
+/**
+ * Map a PCA proof (a PCActn) to an AP2 Payment Mandate so an A2A payment Task can carry it. The mandate's
+ * authority is carried BY REFERENCE: `x_pca.pcactn_digest` binds it to the PCActn, and the mandate is
+ * verified by resolving + verifying that proof (see {@link verifyA2APaymentMandate}).
+ */
+function a2aPaymentMandateFromPca(pcActn, opts) {
+    const leaf = leafHolderOf(pcActn.cap_chain);
+    const issuer = opts.issuerPublic ?? leaf;
+    if (issuer === undefined) {
+        throw new Error('a2aPaymentMandateFromPca: no issuerPublic given and the PCActn has no capability chain');
+    }
+    const humanPresent = opts.humanPresent ?? pcActn.threshold !== undefined;
+    const now = opts.now ?? Date.now();
+    const x_pca = {
+        pcactn_digest: (0, pca_1.pcactnDigest)(pcActn),
+        aud: pcActn.aud,
+        verb: pcActn.action.verb,
+        resource: pcActn.action.resource,
+        params_digest: pcActn.action.params_digest,
+        grant_ref: pcActn.grant_ref,
+        leaf_holder: leaf ?? issuer,
+    };
+    const contents = {
+        amount: { ...opts.amount },
+        payment_method: { ...opts.paymentMethod },
+        human_present: humanPresent,
+        ...(opts.merchant !== undefined ? { merchant: opts.merchant } : {}),
+        x_pca,
+    };
+    return {
+        '@context': exports.A2A_AP2_CONTEXT,
+        type: ['VerifiableCredential', 'PaymentMandate'],
+        issuer,
+        issuanceDate: new Date(now).toISOString(),
+        credentialSubject: contents,
+    };
+}
+/** Read the PCA binding back out of an AP2 Payment Mandate (the round-trip of `x_pca`). */
+function pcaBindingFromA2APaymentMandate(mandate) {
+    return { ...mandate.credentialSubject.x_pca };
+}
+/**
+ * Verify an AP2 Payment Mandate against the PCActn it references. Fail-closed: the mandate's
+ * `x_pca.pcactn_digest` MUST equal `pcactnDigest(pcActn)` (so the mandate is bound to THIS proof), and
+ * the PCActn itself must verify (signature, audience, validity, chain, plan inclusion). This is what makes
+ * the AP2 payment mandate PCA-verifiable rather than a bare assertion.
+ */
+async function verifyA2APaymentMandate(mandate, pcActn, opts) {
+    const bound = mandate.credentialSubject.x_pca.pcactn_digest;
+    if (bound !== (0, pca_1.pcactnDigest)(pcActn)) {
+        return { ok: false, reason: 'payment mandate is not bound to this PCActn (pcactn_digest mismatch)', pcActn };
+    }
+    return verifyPcActn(pcActn, opts);
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,58 @@
 {
   "name": "@atlasauth/pca-a2a",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.0",
+  "description": "A2A (Agent2Agent) adapter for PCA: verify/attach proof-carrying actions on A2A task send/receive, validate Signed Agent Cards, and an AP2 payment-mandate profile.",
+  "keywords": [
+    "a2a",
+    "agent2agent",
+    "agent card",
+    "ap2",
+    "agent authorization",
+    "proof-carrying authority",
+    "pca",
+    "ai agents"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/Atlas-Authorization/pca#readme",
+  "bugs": {
+    "url": "https://github.com/Atlas-Authorization/pca/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Atlas-Authorization/pca.git",
+    "directory": "packages/pca-a2a"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "jose": "^5.9.6",
+    "@atlasauth/pca": "0.2.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.4"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  }
 }