@kya-os/contracts 1.3.5 → 1.4.0

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

@@ -0,0 +1,308 @@
+/**
+ * MCP-I Well-Known Endpoints Specification
+ *
+ * This module defines the types for well-known endpoints as specified in the
+ * MCP-I protocol. These endpoints provide identity discovery and verification
+ * capabilities for MCP-I agents.
+ *
+ * @module @kya-os/contracts/well-known
+ */
+import { z } from 'zod';
+/**
+ * DID Document as per W3C DID specification
+ * Returned from /.well-known/did.json
+ */
+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;
+    }>;
+}
+/**
+ * Agent Document for MCP-I capability discovery
+ * Returned from /.well-known/agent.json
+ */
+export interface AgentDocument {
+    /** The agent's DID */
+    id: string;
+    /** Capabilities supported by this agent */
+    capabilities: {
+        'mcp-i': Array<'handshake' | 'signing' | 'verification' | 'delegation' | 'proof-generation'>;
+        [key: string]: string[];
+    };
+    /** Optional metadata about the agent */
+    metadata?: {
+        name?: string;
+        serviceEndpoint?: string;
+        version?: string;
+        description?: string;
+    };
+}
+/**
+ * MCP Identity information
+ * Returned from /.well-known/mcp-identity
+ */
+export interface MCPIdentity {
+    /** The agent's DID */
+    did: string;
+    /** The agent's public key */
+    publicKey: string;
+    /** Service name */
+    serviceName: string;
+    /** Service endpoint URL */
+    serviceEndpoint: string;
+    /** Timestamp of when this was generated */
+    timestamp: number;
+    /** Optional additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Well-known endpoint handler configuration
+ */
+export interface WellKnownConfig {
+    /** Service name to advertise */
+    serviceName?: string;
+    /** Service endpoint URL */
+    serviceEndpoint?: string;
+    /** Additional metadata to include */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Well-known endpoint response
+ */
+export interface WellKnownResponse {
+    status: number;
+    headers: Record<string, string>;
+    body: string;
+}
+/**
+ * Well-known endpoint paths
+ */
+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"
+}
+/**
+ * Zod Schemas for Validation
+ */
+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;
+}>;
+/**
+ * Type Guards
+ */
+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;
+/**
+ * Validation Functions
+ */
+export declare function validateDIDDocument(obj: any): DIDDocument;
+export declare function validateAgentDocument(obj: any): AgentDocument;
+export declare function validateMCPIdentity(obj: any): MCPIdentity;
+/**
+ * Utility Functions
+ */
+/**
+ * Check if a path is a well-known endpoint
+ */
+export declare function isWellKnownPath(path: string): boolean;
+/**
+ * Get the content type for a well-known endpoint
+ */
+export declare function getWellKnownContentType(path: WellKnownPath | string): string;

package/dist/well-known/index.js

@@ -0,0 +1,134 @@
+"use strict";
+/**
+ * MCP-I Well-Known Endpoints Specification
+ *
+ * This module defines the types for well-known endpoints as specified in the
+ * MCP-I protocol. These endpoints provide identity discovery and verification
+ * capabilities for MCP-I agents.
+ *
+ * @module @kya-os/contracts/well-known
+ */
+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");
+/**
+ * Well-known endpoint paths
+ */
+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 = {}));
+/**
+ * Zod Schemas for Validation
+ */
+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()
+});
+/**
+ * Type Guards
+ */
+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;
+}
+/**
+ * Validation Functions
+ */
+function validateDIDDocument(obj) {
+    return exports.DIDDocumentSchema.parse(obj);
+}
+function validateAgentDocument(obj) {
+    return exports.AgentDocumentSchema.parse(obj);
+}
+function validateMCPIdentity(obj) {
+    return exports.MCPIdentitySchema.parse(obj);
+}
+/**
+ * Utility Functions
+ */
+/**
+ * Check if a path is a well-known endpoint
+ */
+function isWellKnownPath(path) {
+    return Object.values(WellKnownPath).includes(path);
+}
+/**
+ * Get the content type for a well-known endpoint
+ */
+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.5",
+  "version": "1.4.0",
   "description": "Shared types and schemas for XMCP-I ecosystem",
   "type": "commonjs",
   "sideEffects": false,
@@ -91,6 +91,11 @@
       "types": "./dist/config/index.d.ts",
       "import": "./dist/config/index.js",
       "require": "./dist/config/index.js"
+    },
+    "./dashboard-config": {
+      "types": "./dist/dashboard-config/index.d.ts",
+      "import": "./dist/dashboard-config/index.js",
+      "require": "./dist/dashboard-config/index.js"
     }
   },
   "files": [