@kya-os/contracts 1.3.2 → 1.3.3

package/dist/vc/statuslist.js

@@ -1,53 +1,20 @@
 "use strict";
-/**
- * StatusList2021 Types and Schemas
- *
- * Implementation of the W3C StatusList2021 specification for credential status.
- * Provides types for status list credentials and helpers for bitstring operations.
- *
- * Related Spec: W3C StatusList2021
- * Python Reference: Credential-Documentation.md (StatusList2021 section)
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.STATUSLIST_2021_CONTEXT = exports.MAX_STATUSLIST_SIZE = exports.DEFAULT_STATUSLIST_CACHE_TTL_SEC = exports.StatusList2021CredentialSchema = exports.StatusList2021CredentialSubjectSchema = void 0;
 exports.validateStatusList2021Credential = validateStatusList2021Credential;
 exports.createStatusListCredentialStructure = createStatusListCredentialStructure;
 const zod_1 = require("zod");
 const schemas_js_1 = require("./schemas.js");
-/**
- * Status List Credential Subject Schema
- *
- * The credential subject of a StatusList2021Credential
- */
 exports.StatusList2021CredentialSubjectSchema = zod_1.z.object({
-    /** Optional identifier for the status list */
     id: zod_1.z.string().optional(),
-    /** Type MUST be StatusList2021 */
     type: zod_1.z.literal('StatusList2021'),
-    /** Purpose of the status list */
     statusPurpose: zod_1.z.enum(['revocation', 'suspension']),
-    /**
-     * Encoded bitstring
-     *
-     * Base64url-encoded and GZIP-compressed bitstring.
-     * Each bit represents the status of a credential:
-     * - 0: Not revoked/suspended
-     * - 1: Revoked/suspended
-     */
     encodedList: zod_1.z.string().regex(/^[A-Za-z0-9_-]+$/, {
         message: 'encodedList must be base64url encoded',
     }),
 });
-/**
- * StatusList2021 Credential Schema
- *
- * A credential that contains a status list for checking revocation/suspension
- * of other credentials.
- */
 exports.StatusList2021CredentialSchema = zod_1.z.object({
-    /** JSON-LD context */
     '@context': schemas_js_1.ContextSchema.refine((contexts) => {
-        // Must include both base VC context and StatusList context
         return (contexts.length >= 2 &&
             typeof contexts[0] === 'string' &&
             contexts[0] === 'https://www.w3.org/2018/credentials/v1' &&
@@ -57,45 +24,21 @@ exports.StatusList2021CredentialSchema = zod_1.z.object({
     }, {
         message: '@context must include VC context and StatusList2021 context',
     }),
-    /** Unique identifier for the status list credential */
     id: zod_1.z.string().url(),
-    /** Type MUST include VerifiableCredential and StatusList2021Credential */
     type: zod_1.z
         .tuple([zod_1.z.literal('VerifiableCredential'), zod_1.z.literal('StatusList2021Credential')])
         .or(zod_1.z.array(zod_1.z.string()).refine((types) => types.includes('VerifiableCredential') &&
         types.includes('StatusList2021Credential'), {
         message: 'type must include "VerifiableCredential" and "StatusList2021Credential"',
     })),
-    /** Issuer of the status list credential */
     issuer: schemas_js_1.IssuerSchema,
-    /** Issuance date in ISO 8601 format */
     issuanceDate: zod_1.z.string().datetime(),
-    /** The status list credential subject */
     credentialSubject: exports.StatusList2021CredentialSubjectSchema,
-    /** Cryptographic proof (optional) */
     proof: schemas_js_1.ProofSchema.optional(),
 }).passthrough();
-/**
- * Validation Helpers
- */
-/**
- * Validate a StatusList2021 credential
- *
- * @param credential - The credential to validate
- * @returns Validation result with parsed credential or errors
- */
 function validateStatusList2021Credential(credential) {
     return exports.StatusList2021CredentialSchema.safeParse(credential);
 }
-/**
- * Helper to create a minimal status list credential structure
- *
- * This is a type-safe helper, actual credential creation requires
- * proper signing and encoding implementation.
- *
- * @param config - Configuration for the status list credential
- * @returns Partial credential structure (needs proof to be complete)
- */
 function createStatusListCredentialStructure(config) {
     return {
         '@context': [
@@ -113,21 +56,6 @@ function createStatusListCredentialStructure(config) {
         },
     };
 }
-/**
- * Constants
- */
-/**
- * Default cache TTL for status list credentials (in seconds)
- * As per spec recommendation
- */
 exports.DEFAULT_STATUSLIST_CACHE_TTL_SEC = 60;
-/**
- * Maximum reasonable bitstring size
- * Used for validation to prevent memory exhaustion
- */
-exports.MAX_STATUSLIST_SIZE = 1000000; // 1 million entries
-/**
- * StatusList2021 context URL
- */
+exports.MAX_STATUSLIST_SIZE = 1000000;
 exports.STATUSLIST_2021_CONTEXT = 'https://w3id.org/vc/status-list/2021/v1';
-//# sourceMappingURL=statuslist.js.map

package/dist/verifier.d.ts

@@ -1,7 +1,4 @@
 import { z } from "zod";
-/**
- * Verifier middleware schemas and headers
- */
 export declare const AgentContextSchema: z.ZodObject<{
     did: z.ZodString;
     kid: z.ZodString;
@@ -15,13 +12,13 @@ export declare const AgentContextSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     did: string;
     kid: string;
-    scopes: string[];
     session: string;
+    scopes: string[];
     confidence: "verified";
     registry: string;
     verifiedAt: number;
-    subject?: string | undefined;
     delegationRef?: string | undefined;
+    subject?: string | undefined;
 }, {
     did: string;
     kid: string;
@@ -29,9 +26,9 @@ export declare const AgentContextSchema: z.ZodObject<{
     confidence: "verified";
     registry: string;
     verifiedAt: number;
+    delegationRef?: string | undefined;
     subject?: string | undefined;
     scopes?: string[] | undefined;
-    delegationRef?: string | undefined;
 }>;
 export declare const VerifierResultSchema: z.ZodObject<{
     success: z.ZodBoolean;
@@ -49,13 +46,13 @@ export declare const VerifierResultSchema: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         did: string;
         kid: string;
-        scopes: string[];
         session: string;
+        scopes: string[];
         confidence: "verified";
         registry: string;
         verifiedAt: number;
-        subject?: string | undefined;
         delegationRef?: string | undefined;
+        subject?: string | undefined;
     }, {
         did: string;
         kid: string;
@@ -63,9 +60,9 @@ export declare const VerifierResultSchema: z.ZodObject<{
         confidence: "verified";
         registry: string;
         verifiedAt: number;
+        delegationRef?: string | undefined;
         subject?: string | undefined;
         scopes?: string[] | undefined;
-        delegationRef?: string | undefined;
     }>>;
     error: z.ZodOptional<z.ZodObject<{
         code: z.ZodString;
@@ -95,13 +92,13 @@ export declare const VerifierResultSchema: z.ZodObject<{
     agentContext?: {
         did: string;
         kid: string;
-        scopes: string[];
         session: string;
+        scopes: string[];
         confidence: "verified";
         registry: string;
         verifiedAt: number;
-        subject?: string | undefined;
         delegationRef?: string | undefined;
+        subject?: string | undefined;
     } | undefined;
 }, {
     success: boolean;
@@ -119,9 +116,9 @@ export declare const VerifierResultSchema: z.ZodObject<{
         confidence: "verified";
         registry: string;
         verifiedAt: number;
+        delegationRef?: string | undefined;
         subject?: string | undefined;
         scopes?: string[] | undefined;
-        delegationRef?: string | undefined;
     } | undefined;
 }>;
 export declare const StructuredErrorSchema: z.ZodObject<{
@@ -203,4 +200,3 @@ export declare const ERROR_HTTP_STATUS: {
     readonly XMCP_I_SESSION_IDLE_EXPIRED: 401;
     readonly XMCP_I_SERVER_TIME_INVALID: 500;
 };
-//# sourceMappingURL=verifier.d.ts.map

package/dist/verifier.js

@@ -2,9 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ERROR_HTTP_STATUS = exports.VERIFIER_ERROR_CODES = exports.AGENT_HEADERS = exports.StructuredErrorSchema = exports.VerifierResultSchema = exports.AgentContextSchema = void 0;
 const zod_1 = require("zod");
-/**
- * Verifier middleware schemas and headers
- */
 exports.AgentContextSchema = zod_1.z.object({
     did: zod_1.z.string().min(1),
     kid: zod_1.z.string().min(1),
@@ -42,7 +39,6 @@ exports.StructuredErrorSchema = zod_1.z.object({
     })
         .optional(),
 });
-// Header constants (frozen names)
 exports.AGENT_HEADERS = {
     DID: "X-Agent-DID",
     KEY_ID: "X-Agent-KeyId",
@@ -54,7 +50,6 @@ exports.AGENT_HEADERS = {
     REGISTRY: "X-Agent-Registry",
     VERIFIED_AT: "X-Agent-Verified-At",
 };
-// Verifier-specific error codes
 exports.VERIFIER_ERROR_CODES = {
     PROOF_INVALID_TS: "XMCP_I_PROOF_INVALID_TS",
     PROOF_FUTURE_TS: "XMCP_I_PROOF_FUTURE_TS",
@@ -63,7 +58,6 @@ exports.VERIFIER_ERROR_CODES = {
     SESSION_IDLE_EXPIRED: "XMCP_I_SESSION_IDLE_EXPIRED",
     SERVER_TIME_INVALID: "XMCP_I_SERVER_TIME_INVALID",
 };
-// HTTP status mappings
 exports.ERROR_HTTP_STATUS = {
     XMCP_I_EBADPROOF: 403,
     XMCP_I_ENOIDENTITY: 500,
@@ -73,7 +67,6 @@ exports.ERROR_HTTP_STATUS = {
     XMCP_I_ECLAIM: 400,
     XMCP_I_ECONFIG: 500,
     XMCP_I_ERUNTIME: 500,
-    // Verifier-specific codes
     [exports.VERIFIER_ERROR_CODES.PROOF_INVALID_TS]: 403,
     [exports.VERIFIER_ERROR_CODES.PROOF_FUTURE_TS]: 403,
     [exports.VERIFIER_ERROR_CODES.PROOF_TOO_OLD]: 403,
@@ -81,4 +74,3 @@ exports.ERROR_HTTP_STATUS = {
     [exports.VERIFIER_ERROR_CODES.SESSION_IDLE_EXPIRED]: 401,
     [exports.VERIFIER_ERROR_CODES.SERVER_TIME_INVALID]: 500,
 };
-//# sourceMappingURL=verifier.js.map

package/dist/well-known/index.d.ts

@@ -0,0 +1,248 @@
+import { z } from 'zod';
+export interface DIDDocument {
+    '@context': string[];
+    id: string;
+    verificationMethod: Array<{
+        id: string;
+        type: string;
+        controller: string;
+        publicKeyBase64?: string;
+        publicKeyMultibase?: string;
+    }>;
+    authentication?: string[];
+    assertionMethod?: string[];
+    capabilityInvocation?: string[];
+    capabilityDelegation?: string[];
+    keyAgreement?: string[];
+    service?: Array<{
+        id: string;
+        type: string;
+        serviceEndpoint: string;
+    }>;
+}
+export interface AgentDocument {
+    id: string;
+    capabilities: {
+        'mcp-i': Array<'handshake' | 'signing' | 'verification' | 'delegation' | 'proof-generation'>;
+        [key: string]: string[];
+    };
+    metadata?: {
+        name?: string;
+        serviceEndpoint?: string;
+        version?: string;
+        description?: string;
+    };
+}
+export interface MCPIdentity {
+    did: string;
+    publicKey: string;
+    serviceName: string;
+    serviceEndpoint: string;
+    timestamp: number;
+    metadata?: Record<string, unknown>;
+}
+export interface WellKnownConfig {
+    serviceName?: string;
+    serviceEndpoint?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface WellKnownResponse {
+    status: number;
+    headers: Record<string, string>;
+    body: string;
+}
+export declare enum WellKnownPath {
+    DID_DOCUMENT = "/.well-known/did.json",
+    AGENT_DOCUMENT = "/.well-known/agent.json",
+    MCP_IDENTITY = "/.well-known/mcp-identity",
+    TOOL_PROTECTIONS = "/.well-known/tool-protections.json"
+}
+export declare const DIDDocumentSchema: z.ZodObject<{
+    '@context': z.ZodArray<z.ZodString, "many">;
+    id: z.ZodString;
+    verificationMethod: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        controller: z.ZodString;
+        publicKeyBase64: z.ZodOptional<z.ZodString>;
+        publicKeyMultibase: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        id: string;
+        controller: string;
+        publicKeyMultibase?: string | undefined;
+        publicKeyBase64?: string | undefined;
+    }, {
+        type: string;
+        id: string;
+        controller: string;
+        publicKeyMultibase?: string | undefined;
+        publicKeyBase64?: string | undefined;
+    }>, "many">;
+    authentication: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    assertionMethod: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    capabilityInvocation: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    capabilityDelegation: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    keyAgreement: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    service: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        serviceEndpoint: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        id: string;
+        serviceEndpoint: string;
+    }, {
+        type: string;
+        id: string;
+        serviceEndpoint: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    verificationMethod: {
+        type: string;
+        id: string;
+        controller: string;
+        publicKeyMultibase?: string | undefined;
+        publicKeyBase64?: string | undefined;
+    }[];
+    '@context': string[];
+    authentication?: string[] | undefined;
+    assertionMethod?: string[] | undefined;
+    keyAgreement?: string[] | undefined;
+    capabilityInvocation?: string[] | undefined;
+    capabilityDelegation?: string[] | undefined;
+    service?: {
+        type: string;
+        id: string;
+        serviceEndpoint: string;
+    }[] | undefined;
+}, {
+    id: string;
+    verificationMethod: {
+        type: string;
+        id: string;
+        controller: string;
+        publicKeyMultibase?: string | undefined;
+        publicKeyBase64?: string | undefined;
+    }[];
+    '@context': string[];
+    authentication?: string[] | undefined;
+    assertionMethod?: string[] | undefined;
+    keyAgreement?: string[] | undefined;
+    capabilityInvocation?: string[] | undefined;
+    capabilityDelegation?: string[] | undefined;
+    service?: {
+        type: string;
+        id: string;
+        serviceEndpoint: string;
+    }[] | undefined;
+}>;
+export declare const AgentDocumentSchema: z.ZodObject<{
+    id: z.ZodString;
+    capabilities: z.ZodObject<{
+        'mcp-i': z.ZodArray<z.ZodEnum<["handshake", "signing", "verification", "delegation", "proof-generation"]>, "many">;
+    }, "strip", z.ZodArray<z.ZodString, "many">, z.objectOutputType<{
+        'mcp-i': z.ZodArray<z.ZodEnum<["handshake", "signing", "verification", "delegation", "proof-generation"]>, "many">;
+    }, z.ZodArray<z.ZodString, "many">, "strip">, z.objectInputType<{
+        'mcp-i': z.ZodArray<z.ZodEnum<["handshake", "signing", "verification", "delegation", "proof-generation"]>, "many">;
+    }, z.ZodArray<z.ZodString, "many">, "strip">>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        serviceEndpoint: z.ZodOptional<z.ZodString>;
+        version: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        version?: string | undefined;
+        name?: string | undefined;
+        serviceEndpoint?: string | undefined;
+        description?: string | undefined;
+    }, {
+        version?: string | undefined;
+        name?: string | undefined;
+        serviceEndpoint?: string | undefined;
+        description?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    capabilities: {
+        'mcp-i': ("handshake" | "signing" | "verification" | "delegation" | "proof-generation")[];
+    } & {
+        [k: string]: string[];
+    };
+    metadata?: {
+        version?: string | undefined;
+        name?: string | undefined;
+        serviceEndpoint?: string | undefined;
+        description?: string | undefined;
+    } | undefined;
+}, {
+    id: string;
+    capabilities: {
+        'mcp-i': ("handshake" | "signing" | "verification" | "delegation" | "proof-generation")[];
+    } & {
+        [k: string]: string[];
+    };
+    metadata?: {
+        version?: string | undefined;
+        name?: string | undefined;
+        serviceEndpoint?: string | undefined;
+        description?: string | undefined;
+    } | undefined;
+}>;
+export declare const MCPIdentitySchema: z.ZodObject<{
+    did: z.ZodString;
+    publicKey: z.ZodString;
+    serviceName: z.ZodString;
+    serviceEndpoint: z.ZodString;
+    timestamp: z.ZodNumber;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    did: string;
+    publicKey: string;
+    timestamp: number;
+    serviceEndpoint: string;
+    serviceName: string;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    did: string;
+    publicKey: string;
+    timestamp: number;
+    serviceEndpoint: string;
+    serviceName: string;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+export declare const WellKnownConfigSchema: z.ZodObject<{
+    serviceName: z.ZodOptional<z.ZodString>;
+    serviceEndpoint: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    metadata?: Record<string, unknown> | undefined;
+    serviceEndpoint?: string | undefined;
+    serviceName?: string | undefined;
+}, {
+    metadata?: Record<string, unknown> | undefined;
+    serviceEndpoint?: string | undefined;
+    serviceName?: string | undefined;
+}>;
+export declare const WellKnownResponseSchema: z.ZodObject<{
+    status: z.ZodNumber;
+    headers: z.ZodRecord<z.ZodString, z.ZodString>;
+    body: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: number;
+    headers: Record<string, string>;
+    body: string;
+}, {
+    status: number;
+    headers: Record<string, string>;
+    body: string;
+}>;
+export declare function isDIDDocument(obj: any): obj is DIDDocument;
+export declare function isAgentDocument(obj: any): obj is AgentDocument;
+export declare function isMCPIdentity(obj: any): obj is MCPIdentity;
+export declare function validateDIDDocument(obj: any): DIDDocument;
+export declare function validateAgentDocument(obj: any): AgentDocument;
+export declare function validateMCPIdentity(obj: any): MCPIdentity;
+export declare function isWellKnownPath(path: string): boolean;
+export declare function getWellKnownContentType(path: WellKnownPath | string): string;

package/dist/well-known/index.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WellKnownResponseSchema = exports.WellKnownConfigSchema = exports.MCPIdentitySchema = exports.AgentDocumentSchema = exports.DIDDocumentSchema = exports.WellKnownPath = void 0;
+exports.isDIDDocument = isDIDDocument;
+exports.isAgentDocument = isAgentDocument;
+exports.isMCPIdentity = isMCPIdentity;
+exports.validateDIDDocument = validateDIDDocument;
+exports.validateAgentDocument = validateAgentDocument;
+exports.validateMCPIdentity = validateMCPIdentity;
+exports.isWellKnownPath = isWellKnownPath;
+exports.getWellKnownContentType = getWellKnownContentType;
+const zod_1 = require("zod");
+var WellKnownPath;
+(function (WellKnownPath) {
+    WellKnownPath["DID_DOCUMENT"] = "/.well-known/did.json";
+    WellKnownPath["AGENT_DOCUMENT"] = "/.well-known/agent.json";
+    WellKnownPath["MCP_IDENTITY"] = "/.well-known/mcp-identity";
+    WellKnownPath["TOOL_PROTECTIONS"] = "/.well-known/tool-protections.json";
+})(WellKnownPath || (exports.WellKnownPath = WellKnownPath = {}));
+exports.DIDDocumentSchema = zod_1.z.object({
+    '@context': zod_1.z.array(zod_1.z.string()),
+    id: zod_1.z.string(),
+    verificationMethod: zod_1.z.array(zod_1.z.object({
+        id: zod_1.z.string(),
+        type: zod_1.z.string(),
+        controller: zod_1.z.string(),
+        publicKeyBase64: zod_1.z.string().optional(),
+        publicKeyMultibase: zod_1.z.string().optional()
+    })),
+    authentication: zod_1.z.array(zod_1.z.string()).optional(),
+    assertionMethod: zod_1.z.array(zod_1.z.string()).optional(),
+    capabilityInvocation: zod_1.z.array(zod_1.z.string()).optional(),
+    capabilityDelegation: zod_1.z.array(zod_1.z.string()).optional(),
+    keyAgreement: zod_1.z.array(zod_1.z.string()).optional(),
+    service: zod_1.z.array(zod_1.z.object({
+        id: zod_1.z.string(),
+        type: zod_1.z.string(),
+        serviceEndpoint: zod_1.z.string()
+    })).optional()
+});
+exports.AgentDocumentSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    capabilities: zod_1.z.object({
+        'mcp-i': zod_1.z.array(zod_1.z.enum(['handshake', 'signing', 'verification', 'delegation', 'proof-generation']))
+    }).catchall(zod_1.z.array(zod_1.z.string())),
+    metadata: zod_1.z.object({
+        name: zod_1.z.string().optional(),
+        serviceEndpoint: zod_1.z.string().optional(),
+        version: zod_1.z.string().optional(),
+        description: zod_1.z.string().optional()
+    }).optional()
+});
+exports.MCPIdentitySchema = zod_1.z.object({
+    did: zod_1.z.string(),
+    publicKey: zod_1.z.string(),
+    serviceName: zod_1.z.string(),
+    serviceEndpoint: zod_1.z.string(),
+    timestamp: zod_1.z.number(),
+    metadata: zod_1.z.record(zod_1.z.unknown()).optional()
+});
+exports.WellKnownConfigSchema = zod_1.z.object({
+    serviceName: zod_1.z.string().optional(),
+    serviceEndpoint: zod_1.z.string().optional(),
+    metadata: zod_1.z.record(zod_1.z.unknown()).optional()
+});
+exports.WellKnownResponseSchema = zod_1.z.object({
+    status: zod_1.z.number(),
+    headers: zod_1.z.record(zod_1.z.string()),
+    body: zod_1.z.string()
+});
+function isDIDDocument(obj) {
+    return exports.DIDDocumentSchema.safeParse(obj).success;
+}
+function isAgentDocument(obj) {
+    return exports.AgentDocumentSchema.safeParse(obj).success;
+}
+function isMCPIdentity(obj) {
+    return exports.MCPIdentitySchema.safeParse(obj).success;
+}
+function validateDIDDocument(obj) {
+    return exports.DIDDocumentSchema.parse(obj);
+}
+function validateAgentDocument(obj) {
+    return exports.AgentDocumentSchema.parse(obj);
+}
+function validateMCPIdentity(obj) {
+    return exports.MCPIdentitySchema.parse(obj);
+}
+function isWellKnownPath(path) {
+    return Object.values(WellKnownPath).includes(path);
+}
+function getWellKnownContentType(path) {
+    switch (path) {
+        case WellKnownPath.DID_DOCUMENT:
+            return 'application/did+json';
+        case WellKnownPath.AGENT_DOCUMENT:
+        case WellKnownPath.TOOL_PROTECTIONS:
+            return 'application/json';
+        case WellKnownPath.MCP_IDENTITY:
+            return 'application/json';
+        default:
+            return 'application/json';
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kya-os/contracts",
-  "version": "1.3.2",
+  "version": "1.3.3",
   "description": "Shared types and schemas for XMCP-I ecosystem",
   "type": "commonjs",
   "sideEffects": false,
@@ -71,6 +71,26 @@
       "types": "./dist/env/index.d.ts",
       "import": "./dist/env/index.js",
       "require": "./dist/env/index.js"
+    },
+    "./agentshield-api": {
+      "types": "./dist/agentshield-api/index.d.ts",
+      "import": "./dist/agentshield-api/index.js",
+      "require": "./dist/agentshield-api/index.js"
+    },
+    "./tool-protection": {
+      "types": "./dist/tool-protection/index.d.ts",
+      "import": "./dist/tool-protection/index.js",
+      "require": "./dist/tool-protection/index.js"
+    },
+    "./well-known": {
+      "types": "./dist/well-known/index.d.ts",
+      "import": "./dist/well-known/index.js",
+      "require": "./dist/well-known/index.js"
+    },
+    "./config": {
+      "types": "./dist/config/index.d.ts",
+      "import": "./dist/config/index.js",
+      "require": "./dist/config/index.js"
     }
   },
   "files": [
@@ -81,7 +101,8 @@
     "!dist/**/__fixtures__/**",
     "!dist/**/*.spec.*",
     "!dist/**/*.test.*",
-    "README.md"
+    "!README.md",
+    "!*.md"
   ],
   "scripts": {
     "build": "tsc -p tsconfig.build.json && npm run emit-schemas",
@@ -91,16 +112,17 @@
     "type-check": "tsc --noEmit",
     "test": "vitest run",
     "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage"
+    "test:coverage": "vitest run --coverage",
+    "prepublishOnly": "npm run build && node ../create-mcpi-app/scripts/validate-no-workspace.js"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
-    "@vitest/coverage-v8": "^3.2.4",
+    "@vitest/coverage-v8": "^4.0.5",
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
     "fast-check": "^3.15.0",
     "typescript": "^5.0.0",
-    "vitest": "^3.2.4",
+    "vitest": "^4.0.5",
     "zod-to-json-schema": "^3.22.0"
   },
   "dependencies": {