@kya-os/mcp 1.5.0 → 1.6.0

package/CHANGELOG.md

@@ -5,6 +5,73 @@ All notable changes to @kya-os/mcp will be documented here.
 Format: https://keepachangelog.com/en/1.0.0/
 Versioning: https://semver.org/spec/v2.0.0.html
 
+## [Unreleased]
+
+## [1.6.0] - 2026-06-03
+
+Advances the E3 verifier-consolidation groundwork and hardens the delegation
+gate: an isomorphic WebCrypto provider so the proof verifier can run on edge
+runtimes without `node:crypto`, the delegation chain-enforcement rules lifted
+into a framework-agnostic core reusable by any host, and holder-of-key binding
+enforced at the inbound gate. Additive over 1.5.x.
+
+### Added
+
+- `./authz` authorization seam: a neutral, method-agnostic
+  `AuthorizationServerAdapter` port with a shared dispatch predicate, an
+  `AuthorizationServerRegistry` that routes a tool's protection to one adapter,
+  and a generic-OIDC reference adapter under `authz/oidc/` (mandatory S256 PKCE,
+  RFC 8707 resource binding, injectable fetch seam — no named vendor IdP, per
+  the donation's vendor-neutrality). The `AuthorizationRequirement` union
+  (`oauth`/`mdl`/`idv`/`credential`/`none`) anticipates further adapters as
+  siblings of `oidc/`.
+- `AccountabilityContext` projection (agent → accountable-admin → user →
+  intent) that feeds the policy principal's `responsibleParty`; `orgRootDid` is
+  a forward-compatible slot pending the organization root identity.
+- A deterministic, network-free in-memory OIDC example exercising the full
+  authorization path. Additive; no new runtime dependency (zod, jose, Web
+  Crypto only).
+- `GrantStore` provider + `MemoryGrantStore` reference implementation: the
+  post-approval counterpart to `ResumeTokenStore`. A grant binds to the agent
+  DID (durable authority) and optionally to a session (the confused-deputy-safe,
+  no-paste retry convenience — a grant bound to one session is never returned to
+  another). Soft revocation, TTL cleanup, lookup by agent or session. The memory
+  impl is the dev/reference store; production injects Redis / a Durable Object /
+  a database behind the same interface (mirroring `NonceCacheProvider`).
+- **Holder-of-key binding** at the inbound gate (spec §11.8). A delegation
+  credential is a bearer token, so the caller must now prove possession of the
+  delegation subject's key on the request itself. For a `did:key` subject the
+  DID encodes the public key, so binding needs no new credential fields and no
+  new crypto: `assertHolderBinding` verifies the request proof against the key
+  derived from the subject DID — a stolen-credential replay fails signature
+  binding, a tampered request fails content binding, and a proof minted for
+  another server fails audience binding (RFC 8707). The client half
+  (`generateRequestProof`, request-only with a fresh nonce per call) and the PEP
+  half (`assertHolderBinding`) ship in `delegation/holder-binding`. Opt-in.
+- Framework-agnostic delegation **chain-enforcement core**
+  (`validateDelegationChain`, with the injected `DelegationCredentialVerifierPort`
+  and `RevocationChecker` ports, plus `validateScopeAttenuation` /
+  `getDelegationScopes`), lifted out of the `with-kya-os` middleware closure so
+  the leaf→root chain walk, scope attenuation, audience / confused-deputy
+  binding (§11.6), and ancestor-revocation rules run identically in any host
+  (MCP middleware, an HTTP PEP, the conformance harness) instead of a
+  per-transport fork. Dependencies are injected as ports; nothing imports a
+  transport. Includes the correctness fix behind the new graph-backed
+  `RevocationChecker` (reference adapter `CascadingRevocationManager`): a
+  cascade-revoked ancestor is now caught even when the leaf's own StatusList bit
+  never flipped. Exported from `@kya-os/mcp/delegation`.
+- `NoopFetchProvider` — the offline `FetchProvider` fallback (used when the
+  runtime exposes no global `fetch`) extracted from an inline literal into a
+  named, exported class alongside `RuntimeFetchProvider`, and reused at the
+  holder-binding gate.
+- `WebCryptoProvider` — an isomorphic `CryptoProvider` backed by the WebCrypto
+  API (`globalThis.crypto.subtle`, Ed25519), so an edge runtime (Cloudflare
+  Workers, Deno, browsers, Node 20+) can drive `ProofVerifier` without
+  `node:crypto`. Mirrors `NodeCryptoProvider`'s key formats exactly — raw
+  32-byte Ed25519 keys, base64-encoded; `sha256:<hex>` digests — so the two are
+  drop-in interchangeable: a proof signed under one verifies under the other,
+  with byte-identical signatures. Exported from `@kya-os/mcp/providers`.
+
 ## [1.5.0] - 2026-06-01
 
 Exposes the policy-request projection as a reusable primitive and adds a

package/dist/authz/accountability.d.ts

@@ -0,0 +1,35 @@
+import type { DelegationCredentialSubject } from '../types/protocol.js';
+import type { PolicyRequestInput } from '../policy/projection.js';
+/**
+ * The accountability chain behind an agent action: agent -> accountable admin
+ * -> user -> intent. It is a read-only projection of a delegation credential
+ * subject, assembled so policy enforcement has auditable provenance for who is
+ * answerable for an action.
+ *
+ * `accountableAdminDid` is the organization/responsible-admin rung. Today it is
+ * sourced from the credential `controller`; when a dedicated org-admin identity
+ * lands it will be populated from there instead. `orgRootDid` is a
+ * forward-compatible slot that stays undefined until the Org Root DID work
+ * exists — defined now so the contract is stable for downstream consumers.
+ */
+export interface AccountabilityContext {
+    /** The agent acting (delegation subject). */
+    agentDid: string;
+    /** The accountable admin / responsible party, when known. */
+    accountableAdminDid?: string;
+    /** The end user on whose behalf the agent acts, when known. */
+    userDid?: string;
+    /** The organization root identity. Forward-compatible; unpopulated today. */
+    orgRootDid?: string;
+    /** The delegated scopes — the coarse statement of intent. */
+    scopes: string[];
+}
+/** Project the accountability chain from a delegation credential subject. */
+export declare function projectAccountability(subject: DelegationCredentialSubject): AccountabilityContext;
+/**
+ * Map an accountability context onto the policy principal so a PolicyEngine can
+ * gate on accountability. The accountable admin becomes `responsibleParty`,
+ * which is emitted only when present (matching buildPolicyRequest's contract).
+ */
+export declare function accountabilityToPolicyPrincipal(context: AccountabilityContext): PolicyRequestInput['principal'];
+//# sourceMappingURL=accountability.d.ts.map

package/dist/authz/accountability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accountability.d.ts","sourceRoot":"","sources":["../../src/authz/accountability.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAC;AACxE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,qBAAqB;IACpC,6CAA6C;IAC7C,QAAQ,EAAE,MAAM,CAAC;IACjB,6DAA6D;IAC7D,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,+DAA+D;IAC/D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,6EAA6E;IAC7E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,6DAA6D;IAC7D,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,6EAA6E;AAC7E,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,2BAA2B,GACnC,qBAAqB,CAUvB;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,qBAAqB,GAC7B,kBAAkB,CAAC,WAAW,CAAC,CAOjC"}

package/dist/authz/accountability.js

@@ -0,0 +1,28 @@
+/** Project the accountability chain from a delegation credential subject. */
+export function projectAccountability(subject) {
+    const { delegation } = subject;
+    const context = {
+        agentDid: delegation.subjectDid,
+        scopes: delegation.scopes ?? [],
+    };
+    if (delegation.controller)
+        context.accountableAdminDid = delegation.controller;
+    if (delegation.userDid)
+        context.userDid = delegation.userDid;
+    // orgRootDid intentionally left undefined until Org Root DID exists.
+    return context;
+}
+/**
+ * Map an accountability context onto the policy principal so a PolicyEngine can
+ * gate on accountability. The accountable admin becomes `responsibleParty`,
+ * which is emitted only when present (matching buildPolicyRequest's contract).
+ */
+export function accountabilityToPolicyPrincipal(context) {
+    return {
+        agentDid: context.agentDid,
+        ...(context.accountableAdminDid
+            ? { responsibleParty: context.accountableAdminDid }
+            : {}),
+    };
+}
+//# sourceMappingURL=accountability.js.map

package/dist/authz/accountability.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"accountability.js","sourceRoot":"","sources":["../../src/authz/accountability.ts"],"names":[],"mappings":"AA4BA,6EAA6E;AAC7E,MAAM,UAAU,qBAAqB,CACnC,OAAoC;IAEpC,MAAM,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC;IAC/B,MAAM,OAAO,GAA0B;QACrC,QAAQ,EAAE,UAAU,CAAC,UAAU;QAC/B,MAAM,EAAE,UAAU,CAAC,MAAM,IAAI,EAAE;KAChC,CAAC;IACF,IAAI,UAAU,CAAC,UAAU;QAAE,OAAO,CAAC,mBAAmB,GAAG,UAAU,CAAC,UAAU,CAAC;IAC/E,IAAI,UAAU,CAAC,OAAO;QAAE,OAAO,CAAC,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC;IAC7D,qEAAqE;IACrE,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,+BAA+B,CAC7C,OAA8B;IAE9B,OAAO;QACL,QAAQ,EAAE,OAAO,CAAC,QAAQ;QAC1B,GAAG,CAAC,OAAO,CAAC,mBAAmB;YAC7B,CAAC,CAAC,EAAE,gBAAgB,EAAE,OAAO,CAAC,mBAAmB,EAAE;YACnD,CAAC,CAAC,EAAE,CAAC;KACR,CAAC;AACJ,CAAC"}

package/dist/authz/adapter.d.ts

@@ -0,0 +1,47 @@
+import type { NeedsAuthorizationError } from '../types/protocol.js';
+import type { VerifyDelegationResult } from '../auth/types.js';
+import type { AuthorizationRequirement, ToolProtection } from './requirement.js';
+/**
+ * Parameters handed to an adapter when it initiates an authorization flow for a
+ * protected tool. The adapter turns these into a `needs_authorization`
+ * challenge the agent surfaces to the user.
+ */
+export interface FlowParams {
+    /** The protection (tool + requirement) that triggered the flow. */
+    protection: ToolProtection;
+    /** The agent DID requesting access. */
+    agentDid: string;
+    /** Where the authorization server should return control after consent. */
+    redirectUri: string;
+    /** Opaque value echoed back to correlate the result with this request. */
+    state: string;
+}
+/**
+ * The authorization-server port.
+ *
+ * One adapter per authorization *method* (`type`). KYA-OS owns the neutral
+ * requirement/result vocabulary; an adapter renders the method-specific
+ * behavior: decide whether it applies, produce a challenge, verify a result.
+ * Implement this to back authorization with a generic OIDC provider (a
+ * reference adapter ships in this package), or any downstream identity system.
+ * The shape mirrors the policy seam: a small, neutral interface with a
+ * reference implementation and pluggable downstream adapters.
+ */
+export interface AuthorizationServerAdapter {
+    /** The {@link AuthorizationRequirement} discriminant this adapter handles. */
+    readonly type: AuthorizationRequirement['type'];
+    /** Whether this adapter must run for the given tool protection. */
+    isRequired(protection: ToolProtection): boolean;
+    /** Produce a `needs_authorization` challenge for an unmet requirement. */
+    initiateFlow(params: FlowParams): Promise<NeedsAuthorizationError>;
+    /** Verify a returned authorization result into a delegation outcome. */
+    verifyAuthorization(flowState: string, result: unknown): Promise<VerifyDelegationResult>;
+}
+/**
+ * Shared dispatch predicate: a protection is handled by the adapter whose
+ * `type` equals the protection's requirement discriminant. Every adapter's
+ * `isRequired` is built on this, so dispatch stays consistent across adapters
+ * (DRY) and the registry can route a protection to exactly one adapter.
+ */
+export declare function requirementMatchesAdapter(adapterType: AuthorizationRequirement['type'], protection: ToolProtection): boolean;
+//# sourceMappingURL=adapter.d.ts.map

package/dist/authz/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../src/authz/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AACpE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAC/D,OAAO,KAAK,EAAE,wBAAwB,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEjF;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB,mEAAmE;IACnE,UAAU,EAAE,cAAc,CAAC;IAC3B,uCAAuC;IACvC,QAAQ,EAAE,MAAM,CAAC;IACjB,0EAA0E;IAC1E,WAAW,EAAE,MAAM,CAAC;IACpB,0EAA0E;IAC1E,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,0BAA0B;IACzC,8EAA8E;IAC9E,QAAQ,CAAC,IAAI,EAAE,wBAAwB,CAAC,MAAM,CAAC,CAAC;IAEhD,mEAAmE;IACnE,UAAU,CAAC,UAAU,EAAE,cAAc,GAAG,OAAO,CAAC;IAEhD,0EAA0E;IAC1E,YAAY,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAEnE,wEAAwE;IACxE,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;CAC1F;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,wBAAwB,CAAC,MAAM,CAAC,EAC7C,UAAU,EAAE,cAAc,GACzB,OAAO,CAET"}

package/dist/authz/adapter.js

@@ -0,0 +1,10 @@
+/**
+ * Shared dispatch predicate: a protection is handled by the adapter whose
+ * `type` equals the protection's requirement discriminant. Every adapter's
+ * `isRequired` is built on this, so dispatch stays consistent across adapters
+ * (DRY) and the registry can route a protection to exactly one adapter.
+ */
+export function requirementMatchesAdapter(adapterType, protection) {
+    return protection.requirement.type === adapterType;
+}
+//# sourceMappingURL=adapter.js.map

package/dist/authz/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../../src/authz/adapter.ts"],"names":[],"mappings":"AA6CA;;;;;GAKG;AACH,MAAM,UAAU,yBAAyB,CACvC,WAA6C,EAC7C,UAA0B;IAE1B,OAAO,UAAU,CAAC,WAAW,CAAC,IAAI,KAAK,WAAW,CAAC;AACrD,CAAC"}

package/dist/authz/examples/inmemory-oidc.d.ts

@@ -0,0 +1,29 @@
+import type { NeedsAuthorizationError } from '../../types/protocol.js';
+import type { VerifyDelegationResult } from '../../auth/types.js';
+import type { PolicyRequestInput } from '../../policy/projection.js';
+/**
+ * A deterministic, network-free demonstration of the authorization seam.
+ *
+ * Wires the generic-OIDC reference adapter into a registry and backs its single
+ * IdP call (the token exchange) with an in-memory token endpoint, so the full
+ * path runs edge to edge with zero network: protect a tool -> resolve the
+ * adapter -> produce a challenge -> verify the returned code -> map to a
+ * delegation outcome -> derive the policy principal. This is the reliable,
+ * CI-safe showcase of the pluggable adapter pattern; richer live-IdP demos bind
+ * the same port without changing the core.
+ */
+export interface InMemoryFlowParams {
+    toolName: string;
+    requiredScopes: string[];
+    agentDid: string;
+    accountableAdminDid?: string;
+}
+export interface InMemoryFlowOutcome {
+    challenge: NeedsAuthorizationError;
+    result: VerifyDelegationResult;
+    policyPrincipal: PolicyRequestInput['principal'];
+    /** Count of real (non in-memory) network calls — always 0 here. */
+    networkCalls: number;
+}
+export declare function runInMemoryAuthorizationFlow(params: InMemoryFlowParams): Promise<InMemoryFlowOutcome>;
+//# sourceMappingURL=inmemory-oidc.d.ts.map

package/dist/authz/examples/inmemory-oidc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inmemory-oidc.d.ts","sourceRoot":"","sources":["../../../src/authz/examples/inmemory-oidc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AACvE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAMrE;;;;;;;;;;GAUG;AAEH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,uBAAuB,CAAC;IACnC,MAAM,EAAE,sBAAsB,CAAC;IAC/B,eAAe,EAAE,kBAAkB,CAAC,WAAW,CAAC,CAAC;IACjD,mEAAmE;IACnE,YAAY,EAAE,MAAM,CAAC;CACtB;AAwBD,wBAAsB,4BAA4B,CAChD,MAAM,EAAE,kBAAkB,GACzB,OAAO,CAAC,mBAAmB,CAAC,CAoD9B"}

package/dist/authz/examples/inmemory-oidc.js

@@ -0,0 +1,68 @@
+import { AuthorizationServerRegistry } from '../registry.js';
+import { GenericOidcAdapter } from '../oidc/oidc-adapter.js';
+import { accountabilityToPolicyPrincipal } from '../accountability.js';
+/** An in-memory token endpoint standing in for a live OIDC provider. */
+function inMemoryTokenEndpoint(grantedScopes) {
+    let external = 0;
+    const fetchImpl = async (url, init) => {
+        // Only the configured in-memory token endpoint is served; anything else
+        // would be a real network call, which this example never makes.
+        if (url !== 'memory://idp/token') {
+            external += 1;
+            throw new Error(`unexpected external call to ${url}`);
+        }
+        const body = String(init?.body ?? '');
+        if (!body.includes('grant_type=authorization_code') || !body.includes('code_verifier=')) {
+            return new Response('invalid_request', { status: 400 });
+        }
+        return new Response(JSON.stringify({ access_token: 'memory-access-token', token_type: 'Bearer', scope: grantedScopes.join(' ') }), { status: 200, headers: { 'content-type': 'application/json' } });
+    };
+    return { fetchImpl, externalCalls: () => external };
+}
+export async function runInMemoryAuthorizationFlow(params) {
+    const { fetchImpl, externalCalls } = inMemoryTokenEndpoint(params.requiredScopes);
+    const adapter = new GenericOidcAdapter({
+        type: 'oauth',
+        issuer: 'memory://idp',
+        authorizationEndpoint: 'memory://idp/authorize',
+        tokenEndpoint: 'memory://idp/token',
+        clientId: 'example-agent-client',
+        scopes: params.requiredScopes,
+        resource: 'memory://resource/mcp',
+        fetchImpl,
+    });
+    const registry = new AuthorizationServerRegistry();
+    registry.register(adapter);
+    registry.seal();
+    const protection = {
+        toolName: params.toolName,
+        requirement: { type: 'oauth', provider: 'generic-oidc', requiredScopes: params.requiredScopes },
+    };
+    const resolved = registry.resolve(protection);
+    if (!resolved)
+        throw new Error('no adapter resolved for the protected tool');
+    const state = 'example-state';
+    const challenge = await resolved.initiateFlow({
+        protection,
+        agentDid: params.agentDid,
+        redirectUri: 'memory://app/callback',
+        state,
+    });
+    // The user "authorizes": the provider redirects back with a code + state.
+    const result = await resolved.verifyAuthorization(challenge.resumeToken, {
+        code: 'example-auth-code',
+        state,
+    });
+    const accountability = {
+        agentDid: params.agentDid,
+        accountableAdminDid: params.accountableAdminDid,
+        scopes: result.credential?.scopes ?? [],
+    };
+    return {
+        challenge,
+        result,
+        policyPrincipal: accountabilityToPolicyPrincipal(accountability),
+        networkCalls: externalCalls(),
+    };
+}
+//# sourceMappingURL=inmemory-oidc.js.map

package/dist/authz/examples/inmemory-oidc.js.map

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

package/dist/authz/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Authorization-server seam for KYA-OS.
+ *
+ * A neutral, pluggable authorization layer mirroring the policy seam: a small
+ * port ({@link AuthorizationServerAdapter}), a registry that routes a tool's
+ * protection to an adapter, a generic-OIDC reference adapter, and the
+ * accountability projection that feeds the policy principal. Concrete vendor
+ * adapters (commercial identity providers, an identity-provider plugin) live
+ * downstream and bind the same port without changing this core.
+ */
+export { AuthorizationRequirementSchema, ToolProtectionSchema, type AuthorizationRequirement, type ToolProtection, } from './requirement.js';
+export { requirementMatchesAdapter, type AuthorizationServerAdapter, type FlowParams, } from './adapter.js';
+export { buildAuthorizeUrl, type AuthorizeUrlParams } from './oidc/authorize.js';
+export { buildAuthorizationServerMetadata, buildProtectedResourceMetadata, type AuthorizationServerMetadata, type AuthorizationServerMetadataInput, type ProtectedResourceMetadata, type ProtectedResourceMetadataInput, } from './oidc/metadata.js';
+export { isS256ChallengeMethod, computeS256Challenge, verifyS256Challenge, type S256, } from './oidc/pkce.js';
+export { GenericOidcAdapter, type GenericOidcAdapterConfig, type FetchImpl, } from './oidc/oidc-adapter.js';
+export { AuthorizationServerRegistry } from './registry.js';
+export { projectAccountability, accountabilityToPolicyPrincipal, type AccountabilityContext, } from './accountability.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/authz/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/authz/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EACL,8BAA8B,EAC9B,oBAAoB,EACpB,KAAK,wBAAwB,EAC7B,KAAK,cAAc,GACpB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,yBAAyB,EACzB,KAAK,0BAA0B,EAC/B,KAAK,UAAU,GAChB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,iBAAiB,EAAE,KAAK,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAEjF,OAAO,EACL,gCAAgC,EAChC,8BAA8B,EAC9B,KAAK,2BAA2B,EAChC,KAAK,gCAAgC,EACrC,KAAK,yBAAyB,EAC9B,KAAK,8BAA8B,GACpC,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,qBAAqB,EACrB,oBAAoB,EACpB,mBAAmB,EACnB,KAAK,IAAI,GACV,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,kBAAkB,EAClB,KAAK,wBAAwB,EAC7B,KAAK,SAAS,GACf,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAE5D,OAAO,EACL,qBAAqB,EACrB,+BAA+B,EAC/B,KAAK,qBAAqB,GAC3B,MAAM,qBAAqB,CAAC"}

package/dist/authz/index.js

@@ -0,0 +1,19 @@
+/**
+ * Authorization-server seam for KYA-OS.
+ *
+ * A neutral, pluggable authorization layer mirroring the policy seam: a small
+ * port ({@link AuthorizationServerAdapter}), a registry that routes a tool's
+ * protection to an adapter, a generic-OIDC reference adapter, and the
+ * accountability projection that feeds the policy principal. Concrete vendor
+ * adapters (commercial identity providers, an identity-provider plugin) live
+ * downstream and bind the same port without changing this core.
+ */
+export { AuthorizationRequirementSchema, ToolProtectionSchema, } from './requirement.js';
+export { requirementMatchesAdapter, } from './adapter.js';
+export { buildAuthorizeUrl } from './oidc/authorize.js';
+export { buildAuthorizationServerMetadata, buildProtectedResourceMetadata, } from './oidc/metadata.js';
+export { isS256ChallengeMethod, computeS256Challenge, verifyS256Challenge, } from './oidc/pkce.js';
+export { GenericOidcAdapter, } from './oidc/oidc-adapter.js';
+export { AuthorizationServerRegistry } from './registry.js';
+export { projectAccountability, accountabilityToPolicyPrincipal, } from './accountability.js';
+//# sourceMappingURL=index.js.map

package/dist/authz/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/authz/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EACL,8BAA8B,EAC9B,oBAAoB,GAGrB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,yBAAyB,GAG1B,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,iBAAiB,EAA2B,MAAM,qBAAqB,CAAC;AAEjF,OAAO,EACL,gCAAgC,EAChC,8BAA8B,GAK/B,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,qBAAqB,EACrB,oBAAoB,EACpB,mBAAmB,GAEpB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,kBAAkB,GAGnB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAE5D,OAAO,EACL,qBAAqB,EACrB,+BAA+B,GAEhC,MAAM,qBAAqB,CAAC"}

package/dist/authz/oidc/authorize.d.ts

@@ -0,0 +1,25 @@
+import type { S256 } from './pkce.js';
+/**
+ * Inputs to the authorization-code request URL. PKCE is mandatory and S256-only
+ * (see {@link S256}); the optional `resource` is an RFC 8707 resource indicator
+ * binding the issued token's audience to the protected resource.
+ */
+export interface AuthorizeUrlParams {
+    authorizationEndpoint: string;
+    clientId: string;
+    redirectUri: string;
+    scopes: string[];
+    state: string;
+    codeChallenge: string;
+    /** Always S256; present so a caller cannot silently request `plain`. */
+    codeChallengeMethod?: S256;
+    /** RFC 8707 resource indicator (optional). */
+    resource?: string;
+}
+/**
+ * Build an OAuth 2.1 authorization-code request URL. Pure: constructs a URL,
+ * no network. Throws if a non-S256 challenge method is supplied — S256 is
+ * mandatory.
+ */
+export declare function buildAuthorizeUrl(params: AuthorizeUrlParams): string;
+//# sourceMappingURL=authorize.d.ts.map

package/dist/authz/oidc/authorize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authorize.d.ts","sourceRoot":"","sources":["../../../src/authz/oidc/authorize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEtC;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,qBAAqB,EAAE,MAAM,CAAC;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,wEAAwE;IACxE,mBAAmB,CAAC,EAAE,IAAI,CAAC;IAC3B,8CAA8C;IAC9C,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,CAkBpE"}

package/dist/authz/oidc/authorize.js

@@ -0,0 +1,24 @@
+/**
+ * Build an OAuth 2.1 authorization-code request URL. Pure: constructs a URL,
+ * no network. Throws if a non-S256 challenge method is supplied — S256 is
+ * mandatory.
+ */
+export function buildAuthorizeUrl(params) {
+    const method = params.codeChallengeMethod ?? 'S256';
+    if (method !== 'S256') {
+        throw new Error(`Unsupported code_challenge_method "${method}"; S256 is required.`);
+    }
+    const url = new URL(params.authorizationEndpoint);
+    url.searchParams.set('response_type', 'code');
+    url.searchParams.set('client_id', params.clientId);
+    url.searchParams.set('redirect_uri', params.redirectUri);
+    url.searchParams.set('scope', params.scopes.join(' '));
+    url.searchParams.set('state', params.state);
+    url.searchParams.set('code_challenge', params.codeChallenge);
+    url.searchParams.set('code_challenge_method', 'S256');
+    if (params.resource !== undefined) {
+        url.searchParams.set('resource', params.resource);
+    }
+    return url.toString();
+}
+//# sourceMappingURL=authorize.js.map

package/dist/authz/oidc/authorize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"authorize.js","sourceRoot":"","sources":["../../../src/authz/oidc/authorize.ts"],"names":[],"mappings":"AAoBA;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAA0B;IAC1D,MAAM,MAAM,GAAG,MAAM,CAAC,mBAAmB,IAAI,MAAM,CAAC;IACpD,IAAI,MAAM,KAAK,MAAM,EAAE,CAAC;QACtB,MAAM,IAAI,KAAK,CAAC,sCAAsC,MAAM,sBAAsB,CAAC,CAAC;IACtF,CAAC;IAED,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,qBAAqB,CAAC,CAAC;IAClD,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC;IAC9C,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,WAAW,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;IACnD,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,cAAc,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC;IACzD,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;IACvD,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC5C,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,gBAAgB,EAAE,MAAM,CAAC,aAAa,CAAC,CAAC;IAC7D,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,uBAAuB,EAAE,MAAM,CAAC,CAAC;IACtD,IAAI,MAAM,CAAC,QAAQ,KAAK,SAAS,EAAE,CAAC;QAClC,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,UAAU,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;IACpD,CAAC;IACD,OAAO,GAAG,CAAC,QAAQ,EAAE,CAAC;AACxB,CAAC"}

package/dist/authz/oidc/metadata.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Authorization-server and protected-resource metadata assembly (RFC 8414 and
+ * RFC 9728). Pure: shapes the metadata objects from configuration, no network.
+ * S256-only PKCE is advertised unconditionally.
+ */
+export interface AuthorizationServerMetadataInput {
+    issuer: string;
+    authorizationEndpoint: string;
+    tokenEndpoint: string;
+    scopesSupported?: string[];
+    /** Defaults to ['code'] (authorization-code only). */
+    responseTypesSupported?: string[];
+    /** Defaults to ['authorization_code', 'refresh_token']. */
+    grantTypesSupported?: string[];
+    jwksUri?: string;
+    revocationEndpoint?: string;
+}
+/** RFC 8414 Authorization Server Metadata (S256-only PKCE). */
+export interface AuthorizationServerMetadata {
+    issuer: string;
+    authorization_endpoint: string;
+    token_endpoint: string;
+    response_types_supported: string[];
+    grant_types_supported: string[];
+    code_challenge_methods_supported: ['S256'];
+    scopes_supported?: string[];
+    jwks_uri?: string;
+    revocation_endpoint?: string;
+}
+export declare function buildAuthorizationServerMetadata(input: AuthorizationServerMetadataInput): AuthorizationServerMetadata;
+export interface ProtectedResourceMetadataInput {
+    resource: string;
+    authorizationServers: string[];
+    scopesSupported?: string[];
+}
+/** RFC 9728 Protected Resource Metadata. */
+export interface ProtectedResourceMetadata {
+    resource: string;
+    authorization_servers: string[];
+    scopes_supported?: string[];
+}
+export declare function buildProtectedResourceMetadata(input: ProtectedResourceMetadataInput): ProtectedResourceMetadata;
+//# sourceMappingURL=metadata.d.ts.map

package/dist/authz/oidc/metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../../src/authz/oidc/metadata.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,WAAW,gCAAgC;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,qBAAqB,EAAE,MAAM,CAAC;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,sDAAsD;IACtD,sBAAsB,CAAC,EAAE,MAAM,EAAE,CAAC;IAClC,2DAA2D;IAC3D,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,+DAA+D;AAC/D,MAAM,WAAW,2BAA2B;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,sBAAsB,EAAE,MAAM,CAAC;IAC/B,cAAc,EAAE,MAAM,CAAC;IACvB,wBAAwB,EAAE,MAAM,EAAE,CAAC;IACnC,qBAAqB,EAAE,MAAM,EAAE,CAAC;IAChC,gCAAgC,EAAE,CAAC,MAAM,CAAC,CAAC;IAC3C,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,gCAAgC,GACtC,2BAA2B,CAa7B;AAED,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,EAAE,MAAM,CAAC;IACjB,oBAAoB,EAAE,MAAM,EAAE,CAAC;IAC/B,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED,4CAA4C;AAC5C,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,qBAAqB,EAAE,MAAM,EAAE,CAAC;IAChC,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC7B;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,8BAA8B,GACpC,yBAAyB,CAO3B"}

package/dist/authz/oidc/metadata.js

@@ -0,0 +1,32 @@
+/**
+ * Authorization-server and protected-resource metadata assembly (RFC 8414 and
+ * RFC 9728). Pure: shapes the metadata objects from configuration, no network.
+ * S256-only PKCE is advertised unconditionally.
+ */
+export function buildAuthorizationServerMetadata(input) {
+    const metadata = {
+        issuer: input.issuer,
+        authorization_endpoint: input.authorizationEndpoint,
+        token_endpoint: input.tokenEndpoint,
+        response_types_supported: input.responseTypesSupported ?? ['code'],
+        grant_types_supported: input.grantTypesSupported ?? ['authorization_code', 'refresh_token'],
+        code_challenge_methods_supported: ['S256'],
+    };
+    if (input.scopesSupported)
+        metadata.scopes_supported = input.scopesSupported;
+    if (input.jwksUri)
+        metadata.jwks_uri = input.jwksUri;
+    if (input.revocationEndpoint)
+        metadata.revocation_endpoint = input.revocationEndpoint;
+    return metadata;
+}
+export function buildProtectedResourceMetadata(input) {
+    const metadata = {
+        resource: input.resource,
+        authorization_servers: input.authorizationServers,
+    };
+    if (input.scopesSupported)
+        metadata.scopes_supported = input.scopesSupported;
+    return metadata;
+}
+//# sourceMappingURL=metadata.js.map

package/dist/authz/oidc/metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.js","sourceRoot":"","sources":["../../../src/authz/oidc/metadata.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AA4BH,MAAM,UAAU,gCAAgC,CAC9C,KAAuC;IAEvC,MAAM,QAAQ,GAAgC;QAC5C,MAAM,EAAE,KAAK,CAAC,MAAM;QACpB,sBAAsB,EAAE,KAAK,CAAC,qBAAqB;QACnD,cAAc,EAAE,KAAK,CAAC,aAAa;QACnC,wBAAwB,EAAE,KAAK,CAAC,sBAAsB,IAAI,CAAC,MAAM,CAAC;QAClE,qBAAqB,EAAE,KAAK,CAAC,mBAAmB,IAAI,CAAC,oBAAoB,EAAE,eAAe,CAAC;QAC3F,gCAAgC,EAAE,CAAC,MAAM,CAAC;KAC3C,CAAC;IACF,IAAI,KAAK,CAAC,eAAe;QAAE,QAAQ,CAAC,gBAAgB,GAAG,KAAK,CAAC,eAAe,CAAC;IAC7E,IAAI,KAAK,CAAC,OAAO;QAAE,QAAQ,CAAC,QAAQ,GAAG,KAAK,CAAC,OAAO,CAAC;IACrD,IAAI,KAAK,CAAC,kBAAkB;QAAE,QAAQ,CAAC,mBAAmB,GAAG,KAAK,CAAC,kBAAkB,CAAC;IACtF,OAAO,QAAQ,CAAC;AAClB,CAAC;AAeD,MAAM,UAAU,8BAA8B,CAC5C,KAAqC;IAErC,MAAM,QAAQ,GAA8B;QAC1C,QAAQ,EAAE,KAAK,CAAC,QAAQ;QACxB,qBAAqB,EAAE,KAAK,CAAC,oBAAoB;KAClD,CAAC;IACF,IAAI,KAAK,CAAC,eAAe;QAAE,QAAQ,CAAC,gBAAgB,GAAG,KAAK,CAAC,eAAe,CAAC;IAC7E,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/authz/oidc/oidc-adapter.d.ts

@@ -0,0 +1,52 @@
+import { type NeedsAuthorizationError } from '../../types/protocol.js';
+import type { VerifyDelegationResult } from '../../auth/types.js';
+import type { AuthorizationServerAdapter, FlowParams } from '../adapter.js';
+import type { ToolProtection } from '../requirement.js';
+/** A minimal fetch signature — the injectable seam for IdP HTTP calls. */
+export type FetchImpl = (url: string, init?: {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+}) => Promise<Response>;
+export interface GenericOidcAdapterConfig {
+    readonly type: 'oauth';
+    issuer: string;
+    authorizationEndpoint: string;
+    tokenEndpoint: string;
+    clientId: string;
+    scopes: string[];
+    /** RFC 8707 resource indicator bound into the authorize request + token audience. */
+    resource?: string;
+    clientSecret?: string;
+    /** Resume-token lifetime in ms (default 10 minutes). */
+    resumeTokenTtlMs?: number;
+    /** Injected fetch seam; defaults to the runtime global fetch. */
+    fetchImpl?: FetchImpl;
+}
+/**
+ * Reference generic-OIDC authorization-server adapter.
+ *
+ * Implements {@link AuthorizationServerAdapter} for a standards-only OpenID
+ * Connect / OAuth 2.1 provider. No named vendor identity provider appears
+ * here; concrete commercial providers are downstream adapters binding the same
+ * port. The pure pieces (authorize URL, PKCE) run inline; the single IdP HTTP
+ * call (token
+ * exchange) goes through an injectable fetch seam, so the adapter is fully
+ * deterministic under test with no network.
+ *
+ * The PKCE code verifier is held server-side keyed by the resume token and is
+ * never placed in the authorization URL — only the S256 challenge travels.
+ */
+export declare class GenericOidcAdapter implements AuthorizationServerAdapter {
+    private readonly config;
+    readonly type: "oauth";
+    private readonly pending;
+    private readonly fetchImpl;
+    constructor(config: GenericOidcAdapterConfig);
+    isRequired(protection: ToolProtection): boolean;
+    initiateFlow(params: FlowParams): Promise<NeedsAuthorizationError>;
+    verifyAuthorization(flowState: string, result: unknown): Promise<VerifyDelegationResult>;
+    /** Test/inspection seam: the pending code verifier for a resume token, if any. */
+    pendingVerifierFor(resumeToken: string): string | undefined;
+}
+//# sourceMappingURL=oidc-adapter.d.ts.map

package/dist/authz/oidc/oidc-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oidc-adapter.d.ts","sourceRoot":"","sources":["../../../src/authz/oidc/oidc-adapter.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,KAAK,EAAE,0BAA0B,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAI5E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD,0EAA0E;AAC1E,MAAM,MAAM,SAAS,GAAG,CACtB,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,KACxE,OAAO,CAAC,QAAQ,CAAC,CAAC;AAEvB,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,qBAAqB,EAAE,MAAM,CAAC;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,qFAAqF;IACrF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,wDAAwD;IACxD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,iEAAiE;IACjE,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB;AAUD;;;;;;;;;;;;;GAaG;AACH,qBAAa,kBAAmB,YAAW,0BAA0B;IAKvD,OAAO,CAAC,QAAQ,CAAC,MAAM;IAJnC,QAAQ,CAAC,IAAI,EAAG,OAAO,CAAU;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkC;IAC1D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAY;gBAET,MAAM,EAAE,wBAAwB;IAI7D,UAAU,CAAC,UAAU,EAAE,cAAc,GAAG,OAAO;IAIzC,YAAY,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAsClE,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAqD9F,kFAAkF;IAClF,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;CAG5D"}