@kya-os/contracts 1.3.1-canary.0 → 1.3.1-canary.2

package/dist/delegation/schemas.js

@@ -5,18 +5,30 @@
  * Types and schemas for delegation records that link VCs with CRISP constraints.
  * Delegations represent the transfer of authority from one DID to another.
  *
- * Related Spec: MCP-I §4.1, §4.2
+ * **IMPORTANT**: Per Python POC design (Delegation-Service.md:136-146),
+ * delegations SHOULD be issued as W3C Verifiable Credentials, not just reference them.
+ * This file provides both:
+ * - DelegationRecord: Legacy/internal format (contains delegation data)
+ * - DelegationCredential: W3C VC format (delegation as credentialSubject)
+ *
+ * Related Spec: MCP-I §4.1, §4.2, W3C VC Data Model 1.1
  * Python Reference: Delegation-Documentation.md, Delegation-Service.md
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DELEGATION_STATUSES = exports.DEFAULT_DELEGATION_STATUS = exports.MAX_DELEGATION_CHAIN_DEPTH = exports.DelegationVerificationResultSchema = exports.DelegationCreationRequestSchema = exports.DelegationChainSchema = exports.DelegationChainEntrySchema = exports.DelegationRecordSchema = exports.DelegationStatusSchema = void 0;
+exports.DelegationCredentialSchema = exports.DelegationCredentialSubjectSchema = exports.DELEGATION_CREDENTIAL_CONTEXT = exports.DELEGATION_STATUSES = exports.DEFAULT_DELEGATION_STATUS = exports.MAX_DELEGATION_CHAIN_DEPTH = exports.DelegationVerificationResultSchema = exports.DelegationCreationRequestSchema = exports.DelegationChainSchema = exports.DelegationChainEntrySchema = exports.DelegationRecordSchema = exports.DelegationStatusSchema = void 0;
 exports.validateDelegationRecord = validateDelegationRecord;
 exports.validateDelegationChain = validateDelegationChain;
 exports.isDelegationExpired = isDelegationExpired;
 exports.isDelegationNotYetValid = isDelegationNotYetValid;
 exports.isDelegationCurrentlyValid = isDelegationCurrentlyValid;
+exports.validateDelegationCredential = validateDelegationCredential;
+exports.extractDelegationFromVC = extractDelegationFromVC;
+exports.wrapDelegationAsVC = wrapDelegationAsVC;
+exports.isDelegationCredentialExpired = isDelegationCredentialExpired;
+exports.isDelegationCredentialNotYetValid = isDelegationCredentialNotYetValid;
 const zod_1 = require("zod");
 const constraints_js_1 = require("./constraints.js");
+const schemas_js_1 = require("../vc/schemas.js");
 /**
  * Delegation Status
  *
@@ -227,4 +239,238 @@ exports.DEFAULT_DELEGATION_STATUS = 'active';
  * Supported delegation statuses
  */
 exports.DELEGATION_STATUSES = ['active', 'revoked', 'expired'];
+// ============================================================================
+// W3C VC-BASED DELEGATION CREDENTIALS (Phase 3 Implementation)
+// ============================================================================
+/**
+ * Delegation Credential Context
+ *
+ * Additional JSON-LD context for delegation credentials
+ */
+exports.DELEGATION_CREDENTIAL_CONTEXT = 'https://schemas.kya-os.ai/xmcp-i/credentials/delegation.v1.0.0.json';
+/**
+ * Delegation Credential Subject Schema
+ *
+ * The credentialSubject of a DelegationCredential contains:
+ * - id: The delegatee DID (subject of the delegation)
+ * - delegation: The complete delegation record
+ *
+ * Per Python POC (Delegation-Service.md:136-146), delegations are issued AS
+ * W3C VCs, with the delegation data embedded in the credentialSubject.
+ */
+exports.DelegationCredentialSubjectSchema = zod_1.z.object({
+    /** Subject DID (delegatee) */
+    id: zod_1.z.string().min(1),
+    /** The delegation information */
+    delegation: zod_1.z.object({
+        /** Unique identifier for the delegation */
+        id: zod_1.z.string().min(1),
+        /** DID of the delegator (issuer, e.g., merchant/user) */
+        issuerDid: zod_1.z.string().min(1),
+        /** DID of the delegatee (subject, e.g., agent) */
+        subjectDid: zod_1.z.string().min(1),
+        /** Optional controller (user account ID or DID) */
+        controller: zod_1.z.string().optional(),
+        /** Optional parent delegation ID for chain tracking */
+        parentId: zod_1.z.string().optional(),
+        /** CRISP constraints on this delegation */
+        constraints: constraints_js_1.DelegationConstraintsSchema,
+        /** Current status of the delegation */
+        status: exports.DelegationStatusSchema.default('active'),
+        /** Timestamp when created (milliseconds since epoch) */
+        createdAt: zod_1.z.number().int().positive().optional(),
+        /** Optional metadata */
+        metadata: zod_1.z.record(zod_1.z.any()).optional(),
+    }),
+});
+/**
+ * Delegation Credential Schema
+ *
+ * W3C Verifiable Credential for delegations.
+ * This is the PRIMARY format for delegation issuance and verification.
+ *
+ * Structure:
+ * - @context: [...W3C VC contexts, delegation context]
+ * - type: ['VerifiableCredential', 'DelegationCredential']
+ * - issuer: Delegator DID
+ * - issuanceDate: When delegation was created
+ * - expirationDate: Maps to delegation.constraints.notAfter
+ * - credentialSubject: Contains delegatee DID + delegation data
+ * - credentialStatus: StatusList2021Entry for revocation checking
+ * - proof: Ed25519Signature2020
+ *
+ * Per Python POC design (Delegation-Service.md:136-163):
+ * - Every delegation MUST be issued as a VC
+ * - Verification checks BOTH the VC signature AND delegation constraints
+ * - Revocation updates the StatusList2021
+ *
+ * Related Spec: MCP-I §4.1, §4.2, W3C VC Data Model 1.1
+ */
+exports.DelegationCredentialSchema = schemas_js_1.VerifiableCredentialSchema.extend({
+    /** @context MUST include delegation context */
+    '@context': zod_1.z
+        .array(zod_1.z.union([zod_1.z.string().url(), zod_1.z.record(zod_1.z.any())]))
+        .refine((contexts) => {
+        // Check for W3C VC context (first)
+        const firstContext = contexts[0];
+        if (typeof firstContext !== 'string' ||
+            firstContext !== 'https://www.w3.org/2018/credentials/v1') {
+            return false;
+        }
+        // Optionally include delegation context (recommended)
+        return true;
+    }, {
+        message: 'First @context must be W3C VC context',
+    }),
+    /** type MUST include both VerifiableCredential and DelegationCredential */
+    type: zod_1.z
+        .array(zod_1.z.string())
+        .refine((types) => types.includes('VerifiableCredential') &&
+        types.includes('DelegationCredential'), {
+        message: 'type must include both "VerifiableCredential" and "DelegationCredential"',
+    }),
+    /** issuer is the delegator DID */
+    issuer: schemas_js_1.IssuerSchema,
+    /** issuanceDate maps to delegation creation time */
+    issuanceDate: zod_1.z.string().datetime(),
+    /** expirationDate maps to delegation.constraints.notAfter */
+    expirationDate: zod_1.z.string().datetime().optional(),
+    /** credentialSubject contains delegatee DID + delegation data */
+    credentialSubject: exports.DelegationCredentialSubjectSchema,
+    /** credentialStatus for StatusList2021 revocation checking */
+    credentialStatus: schemas_js_1.CredentialStatusSchema.optional(),
+    /** proof is Ed25519Signature2020 */
+    proof: schemas_js_1.ProofSchema.optional(),
+});
+/**
+ * Validate a delegation credential
+ *
+ * @param credential - The delegation credential to validate
+ * @returns Validation result
+ */
+function validateDelegationCredential(credential) {
+    return exports.DelegationCredentialSchema.safeParse(credential);
+}
+/**
+ * Extract DelegationRecord from DelegationCredential
+ *
+ * Utility to extract the legacy DelegationRecord format from a W3C VC.
+ * Useful for backward compatibility and internal processing.
+ *
+ * @param vc - The delegation credential
+ * @returns DelegationRecord
+ */
+function extractDelegationFromVC(vc) {
+    const delegation = vc.credentialSubject.delegation;
+    // Extract signature from proof (may be in different formats)
+    let signature = '';
+    if (vc.proof) {
+        const proof = vc.proof;
+        signature = proof.proofValue || proof.jws || proof.signatureValue || '';
+    }
+    return {
+        id: delegation.id,
+        issuerDid: delegation.issuerDid,
+        subjectDid: delegation.subjectDid,
+        controller: delegation.controller,
+        vcId: vc.id || `vc:${delegation.id}`, // VC id becomes vcId
+        parentId: delegation.parentId,
+        constraints: delegation.constraints,
+        signature,
+        status: delegation.status,
+        createdAt: delegation.createdAt,
+        revokedAt: undefined, // Revocation status comes from credentialStatus
+        revokedReason: undefined,
+        metadata: delegation.metadata,
+    };
+}
+/**
+ * Create DelegationCredential from DelegationRecord (unsigned)
+ *
+ * Wraps a DelegationRecord in a W3C VC structure (without proof).
+ * The caller must sign this to create a valid DelegationCredential.
+ *
+ * @param delegation - The delegation record
+ * @param options - Optional VC options (id, issuanceDate, etc.)
+ * @returns Unsigned DelegationCredential
+ */
+function wrapDelegationAsVC(delegation, options) {
+    const now = new Date().toISOString();
+    const expirationDate = delegation.constraints.notAfter
+        ? new Date(delegation.constraints.notAfter * 1000).toISOString()
+        : options?.expirationDate;
+    // Compute issuanceDate
+    let issuanceDate = options?.issuanceDate || now;
+    if (!options?.issuanceDate && delegation.createdAt) {
+        issuanceDate = new Date(delegation.createdAt).toISOString();
+    }
+    return {
+        '@context': [
+            'https://www.w3.org/2018/credentials/v1',
+            exports.DELEGATION_CREDENTIAL_CONTEXT,
+        ],
+        id: options?.id || delegation.vcId || `urn:uuid:${delegation.id}`,
+        type: ['VerifiableCredential', 'DelegationCredential'],
+        issuer: delegation.issuerDid,
+        issuanceDate,
+        expirationDate,
+        credentialSubject: {
+            id: delegation.subjectDid,
+            delegation: {
+                id: delegation.id,
+                issuerDid: delegation.issuerDid,
+                subjectDid: delegation.subjectDid,
+                controller: delegation.controller,
+                parentId: delegation.parentId,
+                constraints: delegation.constraints,
+                status: delegation.status,
+                createdAt: delegation.createdAt,
+                metadata: delegation.metadata,
+            },
+        },
+        credentialStatus: options?.credentialStatus,
+    };
+}
+/**
+ * Check if a delegation credential is expired
+ *
+ * @param vc - The delegation credential
+ * @returns true if expired
+ */
+function isDelegationCredentialExpired(vc) {
+    // Check VC expiration
+    if (vc.expirationDate) {
+        const expirationDate = new Date(vc.expirationDate);
+        const now = new Date();
+        if (expirationDate < now) {
+            return true;
+        }
+    }
+    // Check delegation constraints notAfter
+    const delegation = vc.credentialSubject.delegation;
+    if (delegation.constraints.notAfter) {
+        const nowSec = Math.floor(Date.now() / 1000);
+        if (nowSec > delegation.constraints.notAfter) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Check if a delegation credential is not yet valid
+ *
+ * @param vc - The delegation credential
+ * @returns true if not yet valid
+ */
+function isDelegationCredentialNotYetValid(vc) {
+    const delegation = vc.credentialSubject.delegation;
+    // Check delegation constraints notBefore
+    if (delegation.constraints.notBefore) {
+        const nowSec = Math.floor(Date.now() / 1000);
+        if (nowSec < delegation.constraints.notBefore) {
+            return true;
+        }
+    }
+    return false;
+}
 //# sourceMappingURL=schemas.js.map

package/dist/did/index.d.ts

@@ -5,4 +5,5 @@
  */
 export * from './types.js';
 export * from './resolve-contract.js';
+export * from './schemas.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/did/index.js

@@ -21,4 +21,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./types.js"), exports);
 __exportStar(require("./resolve-contract.js"), exports);
+__exportStar(require("./schemas.js"), exports);
 //# sourceMappingURL=index.js.map

package/dist/did/schemas.d.ts

@@ -0,0 +1,113 @@
+/**
+ * DID Document Zod Schemas
+ *
+ * Runtime validation schemas for DID Documents conforming to W3C DID Core specification.
+ * These schemas complement the TypeScript types in types.ts with runtime validation.
+ *
+ * Related Spec: MCP-I §2.1, §2.3, W3C DID Core 1.0
+ */
+import { z } from 'zod';
+import type { DidDocument, VerificationMethod, DidService } from './types.js';
+/**
+ * Standard W3C DID Core context
+ */
+export declare const DID_CONTEXT: "https://www.w3.org/ns/did/v1";
+/**
+ * DID Context Entry Schema
+ *
+ * A context entry can be:
+ * - A URL string (most common)
+ * - A context definition object
+ */
+export declare const DidContextEntrySchema: z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>;
+/**
+ * DID @context Schema
+ *
+ * The @context property in DID Documents can be:
+ * - A single string (typically the base DID context)
+ * - An array of strings/objects (base context + additional contexts)
+ * - A context definition object (for custom contexts)
+ *
+ * Per W3C DID Core spec, the base DID context should be present,
+ * but we allow flexibility for different DID methods and extensions.
+ */
+export declare const DidContextSchema: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>, "atleastone">, z.ZodRecord<z.ZodString, z.ZodAny>]>;
+/**
+ * Verification Method Type Schema
+ */
+export declare const VerificationMethodTypeSchema: z.ZodEnum<["Ed25519VerificationKey2020", "JsonWebKey2020", "EcdsaSecp256k1VerificationKey2019"]>;
+/**
+ * Public Key JWK Schema (RFC 7517)
+ */
+export declare const PublicKeyJwkSchema: z.ZodObject<{
+    /** Key Type */
+    kty: z.ZodString;
+    /** Curve (for elliptic curve keys) */
+    crv: z.ZodString;
+    /** X coordinate */
+    x: z.ZodString;
+    /** Y coordinate (optional for some key types) */
+    y: z.ZodOptional<z.ZodString>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    /** Key Type */
+    kty: z.ZodString;
+    /** Curve (for elliptic curve keys) */
+    crv: z.ZodString;
+    /** X coordinate */
+    x: z.ZodString;
+    /** Y coordinate (optional for some key types) */
+    y: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    /** Key Type */
+    kty: z.ZodString;
+    /** Curve (for elliptic curve keys) */
+    crv: z.ZodString;
+    /** X coordinate */
+    x: z.ZodString;
+    /** Y coordinate (optional for some key types) */
+    y: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">>;
+/**
+ * Verification Method Schema
+ */
+export declare const VerificationMethodSchema: z.ZodType<VerificationMethod>;
+/**
+ * DID Service Schema
+ */
+export declare const DidServiceSchema: z.ZodType<DidService>;
+/**
+ * Verification Relationship Entry Schema
+ *
+ * Can be either a string reference to a verification method
+ * or an embedded verification method object.
+ */
+export declare const VerificationRelationshipEntrySchema: z.ZodUnion<[z.ZodString, z.ZodType<VerificationMethod, z.ZodTypeDef, VerificationMethod>]>;
+/**
+ * DID Document Schema
+ *
+ * Validates a DID Document structure per W3C DID Core specification.
+ */
+export declare const DidDocumentSchema: z.ZodType<DidDocument>;
+/**
+ * DID Method Schema
+ */
+export declare const DidMethodSchema: z.ZodEnum<["key", "web", "jwk", "ion", "ebsi"]>;
+/**
+ * Helper function to validate a DID Document
+ *
+ * @param doc - The document to validate
+ * @returns The validated document or throws ZodError
+ */
+export declare function validateDidDocument(doc: unknown): DidDocument;
+/**
+ * Helper function to safely validate a DID Document
+ *
+ * @param doc - The document to validate
+ * @returns Result object with success status and data/error
+ */
+export declare function safeValidateDidDocument(doc: unknown): {
+    success: boolean;
+    data?: DidDocument;
+    error?: z.ZodError;
+};
+//# sourceMappingURL=schemas.d.ts.map

package/dist/did/schemas.js

@@ -0,0 +1,173 @@
+"use strict";
+/**
+ * DID Document Zod Schemas
+ *
+ * Runtime validation schemas for DID Documents conforming to W3C DID Core specification.
+ * These schemas complement the TypeScript types in types.ts with runtime validation.
+ *
+ * Related Spec: MCP-I §2.1, §2.3, W3C DID Core 1.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DidMethodSchema = exports.DidDocumentSchema = exports.VerificationRelationshipEntrySchema = exports.DidServiceSchema = exports.VerificationMethodSchema = exports.PublicKeyJwkSchema = exports.VerificationMethodTypeSchema = exports.DidContextSchema = exports.DidContextEntrySchema = exports.DID_CONTEXT = void 0;
+exports.validateDidDocument = validateDidDocument;
+exports.safeValidateDidDocument = safeValidateDidDocument;
+const zod_1 = require("zod");
+/**
+ * Standard W3C DID Core context
+ */
+exports.DID_CONTEXT = 'https://www.w3.org/ns/did/v1';
+/**
+ * DID Context Entry Schema
+ *
+ * A context entry can be:
+ * - A URL string (most common)
+ * - A context definition object
+ */
+exports.DidContextEntrySchema = zod_1.z.union([
+    zod_1.z.string().url(),
+    zod_1.z.record(zod_1.z.any()),
+]);
+/**
+ * DID @context Schema
+ *
+ * The @context property in DID Documents can be:
+ * - A single string (typically the base DID context)
+ * - An array of strings/objects (base context + additional contexts)
+ * - A context definition object (for custom contexts)
+ *
+ * Per W3C DID Core spec, the base DID context should be present,
+ * but we allow flexibility for different DID methods and extensions.
+ */
+exports.DidContextSchema = zod_1.z.union([
+    // Single string context (e.g., "https://www.w3.org/ns/did/v1")
+    zod_1.z.string().url(),
+    // Array of contexts (strings or objects)
+    zod_1.z.array(exports.DidContextEntrySchema).nonempty(),
+    // Context definition object
+    zod_1.z.record(zod_1.z.any()),
+]);
+/**
+ * Verification Method Type Schema
+ */
+exports.VerificationMethodTypeSchema = zod_1.z.enum([
+    'Ed25519VerificationKey2020',
+    'JsonWebKey2020',
+    'EcdsaSecp256k1VerificationKey2019',
+]);
+/**
+ * Public Key JWK Schema (RFC 7517)
+ */
+exports.PublicKeyJwkSchema = zod_1.z
+    .object({
+    /** Key Type */
+    kty: zod_1.z.string(),
+    /** Curve (for elliptic curve keys) */
+    crv: zod_1.z.string(),
+    /** X coordinate */
+    x: zod_1.z.string(),
+    /** Y coordinate (optional for some key types) */
+    y: zod_1.z.string().optional(),
+})
+    .passthrough(); // Allow additional JWK properties
+/**
+ * Verification Method Schema
+ */
+exports.VerificationMethodSchema = zod_1.z.object({
+    /** Verification method identifier */
+    id: zod_1.z.string(),
+    /** Type of verification method */
+    type: exports.VerificationMethodTypeSchema,
+    /** Controller DID */
+    controller: zod_1.z.string(),
+    /** Multibase-encoded public key (for Ed25519VerificationKey2020) */
+    publicKeyMultibase: zod_1.z.string().optional(),
+    /** JSON Web Key (for JsonWebKey2020) */
+    publicKeyJwk: exports.PublicKeyJwkSchema.optional(),
+});
+/**
+ * DID Service Schema
+ */
+exports.DidServiceSchema = zod_1.z.object({
+    /** Service identifier */
+    id: zod_1.z.string(),
+    /** Service type(s) */
+    type: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]),
+    /** Service endpoint(s) */
+    serviceEndpoint: zod_1.z.union([
+        zod_1.z.string(),
+        zod_1.z.array(zod_1.z.string()),
+        zod_1.z.record(zod_1.z.any()),
+    ]),
+});
+/**
+ * Verification Relationship Entry Schema
+ *
+ * Can be either a string reference to a verification method
+ * or an embedded verification method object.
+ */
+exports.VerificationRelationshipEntrySchema = zod_1.z.union([
+    zod_1.z.string(), // Reference to verification method
+    exports.VerificationMethodSchema, // Embedded verification method
+]);
+/**
+ * DID Document Schema
+ *
+ * Validates a DID Document structure per W3C DID Core specification.
+ */
+exports.DidDocumentSchema = zod_1.z
+    .object({
+    /** JSON-LD context */
+    '@context': exports.DidContextSchema.optional(),
+    /** The DID this document describes */
+    id: zod_1.z.string().refine((val) => val.startsWith('did:'), {
+        message: 'DID must start with "did:"',
+    }),
+    /** Alternative identifiers */
+    alsoKnownAs: zod_1.z.array(zod_1.z.string()).optional(),
+    /** Verification methods */
+    verificationMethod: zod_1.z.array(exports.VerificationMethodSchema).optional(),
+    /** Authentication verification relationship */
+    authentication: zod_1.z.array(exports.VerificationRelationshipEntrySchema).optional(),
+    /** Assertion method verification relationship */
+    assertionMethod: zod_1.z.array(exports.VerificationRelationshipEntrySchema).optional(),
+    /** Key agreement verification relationship */
+    keyAgreement: zod_1.z.array(exports.VerificationRelationshipEntrySchema).optional(),
+    /** Capability invocation verification relationship */
+    capabilityInvocation: zod_1.z
+        .array(exports.VerificationRelationshipEntrySchema)
+        .optional(),
+    /** Capability delegation verification relationship */
+    capabilityDelegation: zod_1.z
+        .array(exports.VerificationRelationshipEntrySchema)
+        .optional(),
+    /** Service endpoints */
+    service: zod_1.z.array(exports.DidServiceSchema).optional(),
+})
+    .passthrough(); // Allow additional properties for extensibility
+/**
+ * DID Method Schema
+ */
+exports.DidMethodSchema = zod_1.z.enum(['key', 'web', 'jwk', 'ion', 'ebsi']);
+/**
+ * Helper function to validate a DID Document
+ *
+ * @param doc - The document to validate
+ * @returns The validated document or throws ZodError
+ */
+function validateDidDocument(doc) {
+    return exports.DidDocumentSchema.parse(doc);
+}
+/**
+ * Helper function to safely validate a DID Document
+ *
+ * @param doc - The document to validate
+ * @returns Result object with success status and data/error
+ */
+function safeValidateDidDocument(doc) {
+    const result = exports.DidDocumentSchema.safeParse(doc);
+    if (result.success) {
+        return { success: true, data: result.data };
+    }
+    return { success: false, error: result.error };
+}
+//# sourceMappingURL=schemas.js.map

package/dist/did/types.d.ts

@@ -21,7 +21,7 @@ export type VerificationMethodType = 'Ed25519VerificationKey2020' | 'JsonWebKey2
  *
  * **kid Derivation Guidelines:**
  * - For did:key: kid = `${did}#${multibaseKey}`
- * - For did:web: kid = `${did}#${keyId}` where keyId is from DID Document
+ * - For did:web: kid = `${did}#${kid}` where kid is from DID Document
  * - The kid MUST be resolvable to a verification method in the DID Document
  */
 export interface VerificationMethod {

package/dist/handshake.d.ts

@@ -28,20 +28,20 @@ export declare const SessionContextSchema: z.ZodObject<{
     ttlMinutes: z.ZodDefault<z.ZodNumber>;
     agentDid: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
+    createdAt: number;
     nonce: string;
     audience: string;
     timestamp: number;
     sessionId: string;
-    createdAt: number;
     lastActivity: number;
     ttlMinutes: number;
     agentDid?: string | undefined;
 }, {
+    createdAt: number;
     nonce: string;
     audience: string;
     timestamp: number;
     sessionId: string;
-    createdAt: number;
     lastActivity: number;
     agentDid?: string | undefined;
     ttlMinutes?: number | undefined;

package/dist/index.d.ts

@@ -19,6 +19,8 @@ export * from "./registry.js";
 export * from "./cli.js";
 export * from "./test.js";
 export * from "./utils/validation.js";
+export * from "./vc/index.js";
+export * from "./delegation/index.js";
 export declare const CONTRACTS_VERSION = "1.2.1";
 export declare const SUPPORTED_XMCP_I_VERSION = "^1.0.0";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -37,6 +37,9 @@ __exportStar(require("./registry.js"), exports);
 __exportStar(require("./cli.js"), exports);
 __exportStar(require("./test.js"), exports);
 __exportStar(require("./utils/validation.js"), exports);
+// W3C VC and Delegation exports (for mcp-i-core compatibility)
+__exportStar(require("./vc/index.js"), exports);
+__exportStar(require("./delegation/index.js"), exports);
 // Version information
 exports.CONTRACTS_VERSION = "1.2.1";
 exports.SUPPORTED_XMCP_I_VERSION = "^1.0.0";