@kya-os/mcp-i-core 1.6.2 → 1.8.0

package/README.md

@@ -151,7 +151,7 @@ import { MCPIRuntimeBaseV2 } from '@kya-os/mcp-i-core';
 class MyPlatformRuntime extends MCPIRuntimeBaseV2 {
   constructor() {
     super({
-      cryptoProvider: new MyeCryptoProvider(),
+      cryptoProvider: new MyCryptoProvider(),
       identityProvider: new MyIdentityProvider(),
       storageProvider: new MyStorageProvider(),
       nonceCacheProvider: new MyNonceCacheProvider(),

package/dist/conformance/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * MCP-I Conformance Level helpers.
+ *
+ * See docs/conformance-levels for the spec page (introduced in
+ * modelcontextprotocol-identity#46).
+ */
+export { validateLevel2, DEFAULT_TRUSTED_ISSUERS, type CapabilityName, type CapabilityAttestation, type CapabilityAttestationCredential, type Level2Capability, type ManifestCapabilities, type CapabilityVCSignatureVerifier, type CapabilityStatusListResolver, type ValidateLevel2Options, type ValidateLevel2Result, type InvalidCapability, } from './validate-level2.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/conformance/index.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * MCP-I Conformance Level helpers.
+ *
+ * See docs/conformance-levels for the spec page (introduced in
+ * modelcontextprotocol-identity#46).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_TRUSTED_ISSUERS = exports.validateLevel2 = void 0;
+var validate_level2_js_1 = require("./validate-level2.js");
+Object.defineProperty(exports, "validateLevel2", { enumerable: true, get: function () { return validate_level2_js_1.validateLevel2; } });
+Object.defineProperty(exports, "DEFAULT_TRUSTED_ISSUERS", { enumerable: true, get: function () { return validate_level2_js_1.DEFAULT_TRUSTED_ISSUERS; } });
+//# sourceMappingURL=index.js.map

package/dist/conformance/validate-level2.d.ts

@@ -0,0 +1,193 @@
+/**
+ * Level 2 Capability Attestation Validator
+ *
+ * Implements the Level 2 conformance behavior described in the MCP-I spec:
+ * https://github.com/modelcontextprotocol-identity/modelcontextprotocol-identity/pull/46
+ *
+ * For each declared capability in the agent manifest, verify at least one
+ * attached Verifiable Credential where ALL of the following hold:
+ *   - VC signature verifies (delegated to a platform-specific verifier)
+ *   - issuer DID is in the trusted issuer registry
+ *   - credentialSubject.id matches the agent DID
+ *   - credentialSubject.capability matches the declared capability name
+ *   - validUntil is in the future (and validFrom is in the past, when present)
+ *
+ * Revocation (StatusList2021) is OPTIONAL for v1 and not enforced here.
+ *
+ * Capabilities that fail validation are NOT thrown — they are returned in the
+ * `invalid` array along with the reasons, so callers can surface diagnostics
+ * to UI without a hard failure.
+ *
+ * The legacy Level 1 `string[]` form is accepted as input: every entry is
+ * returned under `valid` along with a global warning so callers can surface
+ * the missing attestation context.
+ */
+/**
+ * Default trusted issuer registry.
+ *
+ * Matches the spec default: `did:web:knowthat.ai`. Callers MAY substitute or
+ * extend this allowlist via {@link ValidateLevel2Options.trustedIssuers}.
+ */
+export declare const DEFAULT_TRUSTED_ISSUERS: readonly string[];
+/**
+ * Capability name as declared in the agent manifest (e.g. `payments.transfer`).
+ */
+export type CapabilityName = string;
+/**
+ * Minimal shape of a `CapabilityAttestationCredential` per the spec.
+ *
+ * Only the fields the validator inspects are typed strictly — additional
+ * fields (`@context`, `type`, `proof`, etc.) are passed through.
+ */
+export interface CapabilityAttestationCredential {
+    '@context'?: string | string[];
+    type?: string | string[];
+    issuer: string | {
+        id: string;
+    };
+    validFrom?: string;
+    validUntil?: string;
+    credentialSubject: {
+        id: string;
+        capability: string;
+        scope?: Record<string, unknown>;
+    };
+    proof?: unknown;
+    [key: string]: unknown;
+}
+/**
+ * Single attestation entry attached to a Level 2 capability.
+ *
+ * The `vc` field MAY be a compact JWT string (per the spec example) OR a
+ * pre-parsed credential object (convenient for tests and callers that have
+ * already decoded the JWT).
+ *
+ * `issuer` and `type` are OPTIONAL envelope metadata hints — they are
+ * informational only and play NO role in trust evaluation. The validator
+ * derives the authoritative issuer from `vc.issuer` (the signed credential
+ * itself), so a wrong or attacker-supplied envelope `issuer` cannot grant
+ * trust. If you need to record the credential type, prefer `vc.type` inside
+ * the VC, which is covered by the signature.
+ */
+export interface CapabilityAttestation {
+    vc: string | CapabilityAttestationCredential;
+    /**
+     * Optional metadata hint. NOT consulted during validation — `vc.issuer` is
+     * authoritative for the trusted-issuer check.
+     */
+    issuer?: string;
+    /**
+     * Optional metadata hint. NOT consulted during validation.
+     */
+    type?: string;
+}
+/**
+ * Level 2 capability entry.
+ */
+export interface Level2Capability {
+    name: CapabilityName;
+    attestations: CapabilityAttestation[];
+}
+/**
+ * Manifest capabilities — accepts either the legacy Level 1 string array or
+ * the Level 2 object array. Mixed entries within a single Level 2 array are
+ * tolerated (string entries are dropped with a per-capability warning).
+ */
+export type ManifestCapabilities = readonly CapabilityName[] | readonly (Level2Capability | CapabilityName)[];
+/**
+ * Pluggable signature verifier for capability attestations.
+ *
+ * Cryptographic verification (Ed25519, ES256, etc.) is platform-specific, so
+ * the validator delegates the signature check. Implementations should resolve
+ * the issuer DID, locate the verification method, and verify the proof.
+ *
+ * If no verifier is supplied, the validator emits a single global warning and
+ * treats every signature as valid — useful for development but unsafe in
+ * production. This mirrors `DelegationCredentialVerifier`'s behavior when no
+ * `signatureVerifier` is provided.
+ */
+export type CapabilityVCSignatureVerifier = (vc: CapabilityAttestationCredential, rawJwt: string | undefined) => Promise<{
+    valid: boolean;
+    reason?: string;
+}>;
+/**
+ * Reserved hook for StatusList2021-based revocation checks.
+ *
+ * Not invoked in v1. Reserved so callers can pass a resolver today and have
+ * it activate transparently once revocation enforcement lands.
+ */
+export type CapabilityStatusListResolver = (vc: CapabilityAttestationCredential) => Promise<{
+    revoked: boolean;
+    reason?: string;
+}>;
+/**
+ * Validator options.
+ */
+export interface ValidateLevel2Options {
+    /**
+     * The agent DID being validated. `credentialSubject.id` on each VC MUST
+     * match this exactly.
+     */
+    agentDid: string;
+    /**
+     * Trusted issuer DID allowlist. Defaults to {@link DEFAULT_TRUSTED_ISSUERS}.
+     * If supplied, replaces (does NOT merge with) the default — callers wanting
+     * to extend the default should spread it themselves.
+     */
+    trustedIssuers?: readonly string[];
+    /**
+     * Platform-specific signature verifier. If omitted, signatures are accepted
+     * unverified and a global warning is emitted.
+     */
+    signatureVerifier?: CapabilityVCSignatureVerifier;
+    /**
+     * StatusList2021 revocation hook. Reserved — not invoked in v1.
+     *
+     * TODO(v1.x): wire this into the per-attestation check loop once the
+     * StatusList2021 contract is finalized for capability attestations.
+     */
+    statusListResolver?: CapabilityStatusListResolver;
+    /**
+     * Clock injection for tests. Defaults to `new Date()`.
+     */
+    now?: () => Date;
+}
+/**
+ * Per-capability failure record.
+ */
+export interface InvalidCapability {
+    capability: CapabilityName;
+    reasons: string[];
+}
+/**
+ * Validator result.
+ *
+ * - `valid` lists the capability names that passed validation.
+ * - `invalid` lists the capabilities that were declared but failed, with the
+ *   accumulated reasons across every attached attestation.
+ * - `warnings` carries non-fatal diagnostics (e.g. "no signature verifier
+ *   provided", or Level 1 input).
+ */
+export interface ValidateLevel2Result {
+    valid: CapabilityName[];
+    invalid: InvalidCapability[];
+    warnings: string[];
+}
+/**
+ * Validate an MCP-I agent's declared capabilities at Level 2.
+ *
+ * @example
+ * ```ts
+ * const result = await validateLevel2(manifest.capabilities, {
+ *   agentDid: 'did:web:securebank.example',
+ *   trustedIssuers: ['did:web:knowthat.ai'],
+ *   signatureVerifier: myEd25519Verifier,
+ * });
+ *
+ * console.log(result.valid);    // ['payments.transfer']
+ * console.log(result.invalid);  // [{ capability: 'accounts.read', reasons: [...] }]
+ * console.log(result.warnings); // []
+ * ```
+ */
+export declare function validateLevel2(capabilities: unknown, options: ValidateLevel2Options): Promise<ValidateLevel2Result>;
+//# sourceMappingURL=validate-level2.d.ts.map

package/dist/conformance/validate-level2.js

@@ -0,0 +1,284 @@
+"use strict";
+/**
+ * Level 2 Capability Attestation Validator
+ *
+ * Implements the Level 2 conformance behavior described in the MCP-I spec:
+ * https://github.com/modelcontextprotocol-identity/modelcontextprotocol-identity/pull/46
+ *
+ * For each declared capability in the agent manifest, verify at least one
+ * attached Verifiable Credential where ALL of the following hold:
+ *   - VC signature verifies (delegated to a platform-specific verifier)
+ *   - issuer DID is in the trusted issuer registry
+ *   - credentialSubject.id matches the agent DID
+ *   - credentialSubject.capability matches the declared capability name
+ *   - validUntil is in the future (and validFrom is in the past, when present)
+ *
+ * Revocation (StatusList2021) is OPTIONAL for v1 and not enforced here.
+ *
+ * Capabilities that fail validation are NOT thrown — they are returned in the
+ * `invalid` array along with the reasons, so callers can surface diagnostics
+ * to UI without a hard failure.
+ *
+ * The legacy Level 1 `string[]` form is accepted as input: every entry is
+ * returned under `valid` along with a global warning so callers can surface
+ * the missing attestation context.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_TRUSTED_ISSUERS = void 0;
+exports.validateLevel2 = validateLevel2;
+const utils_js_1 = require("../delegation/utils.js");
+/**
+ * Default trusted issuer registry.
+ *
+ * Matches the spec default: `did:web:knowthat.ai`. Callers MAY substitute or
+ * extend this allowlist via {@link ValidateLevel2Options.trustedIssuers}.
+ */
+exports.DEFAULT_TRUSTED_ISSUERS = [
+    'did:web:knowthat.ai',
+];
+/**
+ * Validate an MCP-I agent's declared capabilities at Level 2.
+ *
+ * @example
+ * ```ts
+ * const result = await validateLevel2(manifest.capabilities, {
+ *   agentDid: 'did:web:securebank.example',
+ *   trustedIssuers: ['did:web:knowthat.ai'],
+ *   signatureVerifier: myEd25519Verifier,
+ * });
+ *
+ * console.log(result.valid);    // ['payments.transfer']
+ * console.log(result.invalid);  // [{ capability: 'accounts.read', reasons: [...] }]
+ * console.log(result.warnings); // []
+ * ```
+ */
+async function validateLevel2(capabilities, options) {
+    const result = {
+        valid: [],
+        invalid: [],
+        warnings: [],
+    };
+    if (!Array.isArray(capabilities)) {
+        result.warnings.push('capabilities is not an array — no capabilities validated');
+        return result;
+    }
+    // Level 1 string[] passthrough: every entry is a bare capability name.
+    if (capabilities.length > 0 && capabilities.every((c) => typeof c === 'string')) {
+        result.valid.push(...capabilities);
+        result.warnings.push('Level 1 self-declared — no attestation verified');
+        return result;
+    }
+    const trustedIssuers = new Set(options.trustedIssuers ?? exports.DEFAULT_TRUSTED_ISSUERS);
+    const now = (options.now?.() ?? new Date()).getTime();
+    if (!options.signatureVerifier) {
+        result.warnings.push('No signatureVerifier provided — VC signatures accepted without cryptographic verification');
+    }
+    for (const entry of capabilities) {
+        // Mixed-array case: a bare string in a Level 2 array is unattested per
+        // spec ("MUST treat any capability supplied as a string … as unattested
+        // and therefore ignore it"). We surface it as invalid with a clear reason
+        // so callers can diagnose, rather than dropping silently.
+        if (typeof entry === 'string') {
+            result.invalid.push({
+                capability: entry,
+                reasons: ['capability declared as bare string with no attestations'],
+            });
+            continue;
+        }
+        if (!isLevel2Capability(entry)) {
+            // Entry has a name but malformed/missing attestations — report in invalid.
+            if (typeof entry === 'object' &&
+                entry !== null &&
+                typeof entry.name === 'string') {
+                result.invalid.push({
+                    capability: entry.name,
+                    reasons: ['capability has invalid or missing attestations array'],
+                });
+            }
+            else {
+                result.warnings.push(`Skipping capability entry of unrecognized shape: ${safeStringify(entry)}`);
+            }
+            continue;
+        }
+        const capabilityResult = await validateCapability(entry, {
+            agentDid: options.agentDid,
+            trustedIssuers,
+            now,
+            signatureVerifier: options.signatureVerifier,
+        });
+        if (capabilityResult.valid) {
+            result.valid.push(entry.name);
+        }
+        else {
+            result.invalid.push({
+                capability: entry.name,
+                reasons: capabilityResult.reasons,
+            });
+        }
+    }
+    return result;
+}
+async function validateCapability(capability, ctx) {
+    const reasons = [];
+    if (!Array.isArray(capability.attestations) || capability.attestations.length === 0) {
+        return {
+            valid: false,
+            reasons: ['no attestations attached'],
+        };
+    }
+    for (let i = 0; i < capability.attestations.length; i++) {
+        const attestation = capability.attestations[i];
+        const attestationLabel = `attestation[${i}]`;
+        const parsed = decodeAttestationVC(attestation);
+        if (!parsed.ok) {
+            reasons.push(`${attestationLabel}: ${parsed.reason}`);
+            continue;
+        }
+        const { vc, rawJwt } = parsed;
+        const issuerDid = extractIssuerDid(vc);
+        if (!issuerDid) {
+            reasons.push(`${attestationLabel}: VC missing issuer`);
+            continue;
+        }
+        if (!ctx.trustedIssuers.has(issuerDid)) {
+            reasons.push(`${attestationLabel}: issuer ${issuerDid} not in trusted registry`);
+            continue;
+        }
+        if (vc.credentialSubject?.id !== ctx.agentDid) {
+            reasons.push(`${attestationLabel}: credentialSubject.id ${vc.credentialSubject?.id ?? '(missing)'} does not match agent DID ${ctx.agentDid}`);
+            continue;
+        }
+        if (vc.credentialSubject?.capability !== capability.name) {
+            reasons.push(`${attestationLabel}: credentialSubject.capability ${vc.credentialSubject?.capability ?? '(missing)'} does not match declared capability ${capability.name}`);
+            continue;
+        }
+        const validUntilMs = vc.validUntil ? Date.parse(vc.validUntil) : NaN;
+        if (!vc.validUntil || Number.isNaN(validUntilMs)) {
+            reasons.push(`${attestationLabel}: VC missing or unparseable validUntil`);
+            continue;
+        }
+        if (validUntilMs <= ctx.now) {
+            reasons.push(`${attestationLabel}: VC expired (validUntil ${vc.validUntil})`);
+            continue;
+        }
+        if (vc.validFrom) {
+            const validFromMs = Date.parse(vc.validFrom);
+            if (Number.isNaN(validFromMs)) {
+                reasons.push(`${attestationLabel}: unparseable validFrom`);
+                continue;
+            }
+            if (validFromMs > ctx.now) {
+                reasons.push(`${attestationLabel}: VC not yet valid (validFrom ${vc.validFrom})`);
+                continue;
+            }
+        }
+        if (ctx.signatureVerifier) {
+            let sig;
+            try {
+                sig = await ctx.signatureVerifier(vc, rawJwt);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                reasons.push(`${attestationLabel}: signature verifier threw: ${message}`);
+                continue;
+            }
+            if (!sig.valid) {
+                reasons.push(`${attestationLabel}: signature invalid${sig.reason ? ` (${sig.reason})` : ''}`);
+                continue;
+            }
+        }
+        // TODO(v1.x): when StatusList2021 hook lands, invoke
+        // ctx.statusListResolver here and reject revoked attestations. v1 skips
+        // revocation per the spec design doc.
+        return { valid: true, reasons: [] };
+    }
+    return { valid: false, reasons };
+}
+/**
+ * Decode an attestation `vc` field (string JWT or object) into a credential.
+ */
+function decodeAttestationVC(attestation) {
+    if (attestation === null || typeof attestation !== 'object') {
+        return { ok: false, reason: 'attestation entry is not an object' };
+    }
+    const vc = attestation.vc;
+    if (typeof vc === 'string') {
+        const parsed = (0, utils_js_1.parseVCJWT)(vc);
+        if (!parsed) {
+            return { ok: false, reason: 'VC JWT could not be parsed' };
+        }
+        const inner = parsed.payload.vc;
+        if (!inner || typeof inner !== 'object') {
+            return { ok: false, reason: 'VC JWT payload missing vc claim' };
+        }
+        // Per W3C VC-JWT spec §6.3: promote JWT-level iss→vc.issuer and
+        // sub→vc.credentialSubject.id when absent from the embedded vc object so
+        // that externally-issued spec-compliant JWTs are not falsely rejected.
+        const merged = { ...inner };
+        if (!merged.issuer && typeof parsed.payload.iss === 'string') {
+            merged.issuer = parsed.payload.iss;
+        }
+        if (typeof parsed.payload.sub === 'string' &&
+            merged.credentialSubject &&
+            typeof merged.credentialSubject === 'object' &&
+            !merged.credentialSubject.id) {
+            merged.credentialSubject = {
+                ...merged.credentialSubject,
+                id: parsed.payload.sub,
+            };
+        }
+        // Per W3C VC-JWT spec §6.3: also promote exp→validUntil and nbf→validFrom
+        // when absent from the embedded vc object, so externally-issued JWTs that
+        // carry validity only in the standard JWT claims are not falsely rejected.
+        // JWT exp/nbf are Unix seconds (NumericDate). Guard the conversion: an
+        // out-of-range claim yields an Invalid Date, which we leave unset (→ the VC
+        // fails closed at validation) rather than letting toISOString() throw a
+        // RangeError out of this otherwise-total decoder.
+        if (!merged.validUntil && typeof parsed.payload.exp === 'number') {
+            const d = new Date(parsed.payload.exp * 1000);
+            if (!Number.isNaN(d.getTime()))
+                merged.validUntil = d.toISOString();
+        }
+        if (!merged.validFrom && typeof parsed.payload.nbf === 'number') {
+            const d = new Date(parsed.payload.nbf * 1000);
+            if (!Number.isNaN(d.getTime()))
+                merged.validFrom = d.toISOString();
+        }
+        return {
+            ok: true,
+            vc: merged,
+            rawJwt: vc,
+        };
+    }
+    if (vc && typeof vc === 'object') {
+        return {
+            ok: true,
+            vc: vc,
+            rawJwt: undefined,
+        };
+    }
+    return { ok: false, reason: 'attestation.vc missing or invalid type' };
+}
+function extractIssuerDid(vc) {
+    if (typeof vc.issuer === 'string')
+        return vc.issuer;
+    if (vc.issuer && typeof vc.issuer === 'object' && typeof vc.issuer.id === 'string') {
+        return vc.issuer.id;
+    }
+    return undefined;
+}
+function isLevel2Capability(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        typeof value.name === 'string' &&
+        Array.isArray(value.attestations));
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+//# sourceMappingURL=validate-level2.js.map

package/dist/delegation/outbound-proof.d.ts

@@ -6,9 +6,10 @@
  * without trusting the MCP server.
  *
  * Wire format: signed compact EdDSA JWT (60s TTL, per-call jti)
- * Header injection: X-Delegation-Id, X-Delegation-Chain, X-Delegation-Proof, X-Scopes
+ * Header injection: KYA-OS-Delegation-Chain, KYA-OS-Delegation-Proof, KYA-OS-Granted-Scopes,
+ * and KYA-OS-Delegation-Credential (the JWS-compact DelegationCredential VC) when present
  *
- * Related Spec: MCP-I §2 — Outbound Delegation Propagation
+ * Related Spec: DIF MCP-I §8 — Outbound Delegation Propagation
  */
 import type { DelegationRecord } from "@kya-os/contracts/delegation";
 /**

package/dist/delegation/outbound-proof.js

@@ -7,9 +7,10 @@
  * without trusting the MCP server.
  *
  * Wire format: signed compact EdDSA JWT (60s TTL, per-call jti)
- * Header injection: X-Delegation-Id, X-Delegation-Chain, X-Delegation-Proof, X-Scopes
+ * Header injection: KYA-OS-Delegation-Chain, KYA-OS-Delegation-Proof, KYA-OS-Granted-Scopes,
+ * and KYA-OS-Delegation-Credential (the JWS-compact DelegationCredential VC) when present
  *
- * Related Spec: MCP-I §2 — Outbound Delegation Propagation
+ * Related Spec: DIF MCP-I §8 — Outbound Delegation Propagation
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildDelegationProofJWT = buildDelegationProofJWT;

package/dist/delegation/utils.d.ts

@@ -40,8 +40,10 @@ export interface VCJWTPayload {
     sub?: string;
     /** Audience (e.g., project ID the credential is scoped to). Per RFC 7519, can be string or array. */
     aud?: string | string[];
-    /** Expiration time (from vc.expirationDate) */
+    /** Expiration time (from vc.expirationDate / validUntil) */
     exp?: number;
+    /** Not-before time (RFC 7519 nbf; maps to vc.validFrom) */
+    nbf?: number;
     /** Issued at time (from vc.issuanceDate) */
     iat?: number;
     /** JWT ID (from vc.id) */

package/dist/index.d.ts

@@ -1,53 +1,14 @@
 /**
  * @kya-os/mcp-i-core
  *
- * Core provider-based architecture for MCP-I framework.
- * Platform-agnostic runtime that can be extended for any environment.
+ * Compatibility shim. The product-runtime layer has relocated to
+ * @kya-os/mcp-i-runtime; this package re-exports it so existing
+ * `@kya-os/mcp-i-core` importers keep resolving during the C4 drain window.
+ *
+ * Delegation (W3C VC) symbols remain sourced here — `src/delegation/**` is
+ * pinned by E3.5 (#2904) and is intentionally NOT relocated.
  */
-export { CryptoProvider, ClockProvider, FetchProvider, StorageProvider, NonceCacheProvider, IdentityProvider, type AgentIdentity, } from "./providers/base";
-export { MemoryStorageProvider, MemoryNonceCacheProvider, MemoryIdentityProvider, } from "./providers/memory";
-export { MCPIRuntimeBase } from "./runtime/base";
-export type { RuntimeWithAccessControl } from "./runtime/base";
-export { CONSENT_UI_RESOURCE_URI } from "./runtime/ext-apps-constants";
-export type { IAuditLogger } from "./runtime/audit-logger";
-export * from "./utils";
-export { ToolProtectionService } from "./services/tool-protection.service";
-export { PolicyService } from "./services/policy.service";
-export type { PolicyEvaluationContext, PolicyEvaluationResult, PolicyServiceConfig, } from "./services/policy.service";
-export { CryptoService } from "./services/crypto.service";
-export type { Ed25519JWK, ParsedJWS } from "./services/crypto.service";
-export { ProofVerifier } from "./services/proof-verifier";
-export type { ProofVerificationResult, ProofVerifierConfig, } from "./services/proof-verifier";
-export { AccessControlApiService, authorizationMatches, } from "./services/access-control.service";
-export type { AccessControlApiServiceConfig, AccessControlApiServiceMetrics, } from "./services/access-control.service";
-export { SessionRegistrationService, createSessionRegistrationService, } from "./services/session-registration.service";
-export type { SessionRegistrationServiceConfig, SessionRegistrationResult, } from "./services/session-registration.service";
-export { OAuthConfigService } from "./services/oauth-config.service";
-export type { OAuthConfigServiceConfig } from "./services/oauth-config.service";
-export { OAuthService, defaultSecretResolver } from "./services/oauth-service";
-export type { OAuthServiceConfig, SecretResolver } from "./services/oauth-service";
-export { ToolContextBuilder } from "./services/tool-context-builder";
-export type { ToolContextBuilderConfig } from "./services/tool-context-builder";
-export { OAuthProviderRegistry } from "./services/oauth-provider-registry";
-export { ProviderResolver, ConsentOnlyModeError, CredentialAuthModeError, } from "./services/provider-resolver";
-export { ProviderValidator, ProviderValidationError, } from "./services/provider-validator";
-export { OAuthTokenRetrievalService } from "./services/oauth-token-retrieval.service";
-export type { OAuthTokenRetrievalServiceConfig } from "./services/oauth-token-retrieval.service";
-export { BatchDelegationService } from "./services/batch-delegation.service";
-export type { ToolGroup } from "./services/batch-delegation.service";
-export { InMemoryOAuthConfigCache, NoOpOAuthConfigCache, } from "./cache/oauth-config-cache";
-export type { OAuthConfigCache } from "./cache/oauth-config-cache";
-export { createStorageProviders, StorageKeyHelpers, migrateLegacyKeys, } from "./services/storage.service";
-export type { StorageServiceConfig, StorageProviders, } from "./services/storage.service";
-export { ProofVerificationError, PROOF_VERIFICATION_ERROR_CODES, createProofVerificationError, } from "./services/errors";
-export type { ProofVerificationErrorCode } from "./services/errors";
-export { ToolProtectionCache, InMemoryToolProtectionCache, NoOpToolProtectionCache, } from "./cache/tool-protection-cache";
-export type { ToolProtection, ToolProtectionConfig, ToolProtectionServiceConfig, } from "./types/tool-protection";
-export { DelegationRequiredError } from "./types/tool-protection";
-export { OAuthRequiredError } from "./types/oauth-required-error";
-export type { OAuthRequiredErrorOptions } from "./types/oauth-required-error";
-export { DelegationErrorFormatter, createDelegationErrorFormatter, } from "./services/delegation-error-formatter";
-export type { DelegationErrorFormatOptions, DelegationErrorResult, ClientMessageTemplate, ClientMessagesConfig, } from "./services/delegation-error-formatter";
+export * from "@kya-os/mcp-i-runtime";
 export { DelegationCredentialIssuer, createDelegationIssuer, type IssueDelegationOptions, type VCSigningFunction, type IdentityProvider as DelegationIdentityProvider, } from "./delegation/vc-issuer";
 export { DelegationCredentialVerifier, createDelegationVerifier, type DelegationVCVerificationResult, type VerifyDelegationVCOptions, type DIDResolver, type DIDDocument, type VerificationMethod, type StatusListResolver, type SignatureVerificationFunction, } from "./delegation/vc-verifier";
 export { StatusList2021Manager, createStatusListManager, type StatusListStorageProvider, type StatusListIdentityProvider, } from "./delegation/statuslist-manager";
@@ -58,22 +19,6 @@ export { MemoryStatusListStorage } from "./delegation/storage/memory-statuslist-
 export { MemoryDelegationGraphStorage } from "./delegation/storage/memory-graph-storage";
 export { buildDelegationProofJWT, buildChainString, type DelegationProofOptions, type Ed25519PrivateJWK, } from "./delegation/outbound-proof";
 export { createDidKeyResolver, isEd25519DidKey, extractPublicKeyFromDidKey, publicKeyToJwk, resolveDidKeySync, } from "./delegation/did-key-resolver";
-export { base58Encode, base58Decode, isValidBase58 } from "./utils/base58";
-export { SchemaVerifier, createSchemaVerifier, type SchemaMetadata, type FieldComplianceResult, type SchemaComplianceReport, type FullComplianceReport, } from "./compliance/schema-verifier";
-export { SCHEMA_REGISTRY, getAllSchemas, getSchemasByCategory, getSchemaById, getCriticalSchemas, getSchemaStats, } from "./compliance/schema-registry";
 export { canonicalizeJSON, createUnsignedVCJWT, completeVCJWT, parseVCJWT, type VCJWTHeader, type VCJWTPayload, type EncodeVCAsJWTOptions, } from "./delegation/utils";
-export { base64urlEncodeFromBytes, base64urlEncodeFromString, base64urlDecodeToBytes, base64urlDecodeToString, bytesToBase64, } from "./utils/base64";
-import type { HandshakeRequest, SessionContext, NonceCache, NonceCacheEntry, NonceCacheConfig, ProofMeta, DetachedProof, CanonicalHashes, AuditRecord } from "@kya-os/contracts";
-export type { HandshakeRequest, SessionContext, NonceCache, NonceCacheEntry, NonceCacheConfig, ProofMeta, DetachedProof, CanonicalHashes, AuditRecord, };
-export * from "./config";
-export { fetchRemoteConfig, type RemoteConfigCache, type RemoteConfigOptions, getToolProtection, extractToolProtections, hasMergedToolProtections, getPolicy, extractPolicy, hasMergedPolicy, isPolicyEnabled, } from "./config/remote-config";
-export { UserDidManager } from "./identity/user-did-manager";
-export type { UserDidStorage, UserDidManagerConfig, UserKeyPair, OAuthIdentity, } from "./identity/user-did-manager";
-export { IdpTokenResolver } from "./identity/idp-token-resolver";
-export type { IdpTokenResolverConfig } from "./identity/idp-token-resolver";
-export type { IIdpTokenStorage, TokenUsageMetadata, IdpTokensWithMetadata, } from "./identity/idp-token-storage.interface";
-export { logger, createDefaultConsoleLogger, type Logger, type Level, } from "./logging";
-export { ProofGenerator, createProofResponse, extractCanonicalData, type ProofAgentIdentity, type ToolRequest, type ToolResponse, type ProofOptions, } from "./proof";
-export { SessionManager, createHandshakeRequest, validateHandshakeFormat, type SessionConfig, type HandshakeResult, } from "./session";
-export { verifyOrHints, hasSensitiveScopes, MemoryResumeTokenStore, type AuthHandshakeConfig, type VerifyOrHintsResult, type AgentReputation, type ResumeTokenStore, type DelegationVerifier, type VerifyDelegationResult, } from "./auth";
+export { validateLevel2, DEFAULT_TRUSTED_ISSUERS, type CapabilityName, type CapabilityAttestation, type CapabilityAttestationCredential, type Level2Capability, type ManifestCapabilities, type CapabilityVCSignatureVerifier, type CapabilityStatusListResolver, type ValidateLevel2Options, type ValidateLevel2Result, type InvalidCapability, } from "./conformance/index.js";
 //# sourceMappingURL=index.d.ts.map