@kya-os/mcp-i 0.1.0-alpha.3.9 → 1.2.0

package/README.md

@@ -1,315 +1,452 @@
-# @kya-os/mcp-i
+<div align="center">
+  <a href="https://github.com/modelcontextprotocol-identity/xmcp-i">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/modelcontextprotocol-identity/xmcp-i/main/assets/mcp-i-logo-dark.png">
+      <img alt="MCP-I logo" src="https://raw.githubusercontent.com/modelcontextprotocol-identity/xmcp-i/main/assets/mcp-i-logo-light.png" height="128">
+    </picture>
+  </a>
+  <h1>xmcp-i</h1>
 
-The SEO package for AI agents. Register your MCP server and get automatic directory listings in 2 lines of code.
+<a href="https://github.com/modelcontextprotocol-identity/xmcp-i"><img alt="XMCP-I" src="https://img.shields.io/badge/XMCP--I-000000.svg?style=for-the-badge&labelColor=000"></a>
+<a href="https://www.npmjs.com/package/xmcp-i"><img alt="NPM version" src="https://img.shields.io/npm/v/xmcp-i.svg?style=for-the-badge&labelColor=000000"></a>
+<a href="https://github.com/modelcontextprotocol-identity/xmcp-i/blob/main/license.md"><img alt="License" src="https://img.shields.io/npm/l/xmcp-i.svg?style=for-the-badge&labelColor=000000"></a>
 
-Note: This package is alpha release, do not use in production.
-v1.0.0 will be released this week.
+</div>
 
-[![npm version](https://img.shields.io/npm/v/@kya-os/mcp-i.svg)](https://www.npmjs.com/package/@kya-os/mcp-i)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![MCP-I Conformance](https://img.shields.io/badge/MCP--I-Level%202-green)](https://modelcontextprotocol-identity.io)
+## Own Your AI Agent with Cryptographic Identity
 
-## Why Your MCP Server Needs This
+`xmcp-i` enables you to **create your own AI agents** with cryptographic identity and secure delegation. Register and claim your agents with [knowthat.ai](https://knowthat.ai), store your identity securely within them, and delegate or revoke permissions as needed. Built on the XMCP framework with identity features baked in from day one.
 
-**For MCP Server Developers:**
+## Quick Start
+
+Create your first owned AI agent:
+
+```bash
+npx @kya-os/create-xmcpi-app@latest my-agent
+```
+
+Then register and claim ownership at [knowthat.ai](https://knowthat.ai)
+
+> **New to XMCP-I?** Use [`@kya-os/create-xmcpi-app`](https://www.npmjs.com/package/@kya-os/create-xmcpi-app) to scaffold a complete agent with identity. For existing projects, install `@kya-os/xmcpi` directly.
+
+## Installation
+
+### For New Projects
+
+```bash
+npx create-xmcpi-app@latest my-agent
+```
+
+### For Existing Projects
+
+```bash
+npx init-xmcp-i@latest
+```
+
+This will add identity features to your existing Node.js/TypeScript project with automatic framework detection and configuration.
+
+## Why Agent Ownership Matters
+
+⊹ **True Ownership** - Your agent belongs to you, not a platform\
+⊹ **Cryptographic Security** - Ed25519 keys and DID-based identity\
+⊹ **Permission Control** - Delegate and revoke capabilities securely\
+⊹ **Verifiable Actions** - All responses are cryptographically signed\
+⊹ **Decentralized Trust** - No central authority controls your agent\
+⊹ **Portable Identity** - Move your agent between platforms while keeping ownership
 
-- **Get a DID** - Your agent gets a permanent, cryptographic identity from knowthat.ai
-- **Automatic Directory Listings** - Submit to multiple directories with zero extra work
-- **Build Reputation** - Every interaction is signed and verifiable
-- **Future-Proof** - Ready for the decentralized agent ecosystem
-- **Production-Ready** - Optimized for Lambda, Edge, Next.js, and traditional deployments
-- **Fast Registration** - New CLI endpoint provides 100-200ms registration (10-50x faster!)
+### Cryptographic Foundation
 
-**For Directory Maintainers:**
+- **DID Generation**: Decentralized identifiers from public keys
+- **Automatic Signing**: All responses signed with your private key
+- **Key Security**: Private keys never leave your control
 
-- **Easy Integration** - List MCP-I compliant agents automatically
-- **Verified Agents** - Only list agents with cryptographic proof
-- **Join the Network** - Tap into the growing MCP-I ecosystem
+## Security and Trust
 
-## How It Works
+**Agent Ownership Verification**: Every XMCP-I agent generates a cryptographic proof of ownership that can be verified independently. When you register your agent with knowthat.ai, you establish a permanent, tamper-proof claim to your agent's identity.
 
-1. **Identity Registration**: Your agent is registered with knowthat.ai (the MCP-I registry)
-2. **DID Generation**: You get a `did:web:knowthat.ai:agents:your-agent` identifier
-3. **Directory Submission**: Based on your preferences, knowthat.ai submits your agent to directories
-4. **Cryptographic Signing**: All agent responses are signed with your private key
-5. **Verification**: Anyone can verify your agent's identity and authenticity
+**Decentralized Trust**: Your agent's identity doesn't depend on any central authority. The cryptographic keys are generated locally and never shared. Even if knowthat.ai goes offline, your agent retains its identity and ownership proof.
+
+**Secure Delegation**: Permission delegation uses time-bound, cryptographically signed tokens. You can grant specific capabilities to other users or systems, with full audit trails and instant revocation capabilities.
+
+## Real-World Benefits for Developers & Businesses
+
+### Privacy-First Tracking & Analytics
+
+Unlike traditional web tracking (cookies, pixels), XMCP-I provides **ethical data collection**:
+
+- Users can see exactly what data is stored about them
+- Users can revoke access instantly at any time
+- Businesses get analytics for retargeting without violating privacy
+- Think "GDPR-compliant by design" - users control their data completely
+
+### XMCP-I Allows AI in Regulated Industries
+
+Industries like healthcare, law, and finance can now use AI while maintaining compliance:
+
+**The Problem**: These industries need AI efficiency but can't use most AI services due to:
+
+- Data privacy regulations (HIPAA, GDPR, SOX)
+- Audit requirements (who did what, when?)
+- Client confidentiality obligations
+
+**The Solution**: XMCP-I provides:
+
+- **Provable Privacy**: Cryptographic proof of data handling
+- **Complete Audit Trails**: Every AI action is signed and traceable
+- **User Control**: Clients can revoke AI access to their data instantly
+- **Regulatory Compliance**: Built-in features for GDPR, HIPAA, etc.
+- **EU AI Act Compliance**: Built-in audit trails and user consent mechanisms
+
+**Real Example**: A law firm can now use AI for document review because:
+
+- Clients control exactly which documents the AI can access
+- All AI actions are cryptographically logged
+- Clients can revoke access immediately if they switch firms
+- The firm can prove to regulators exactly how data was handled
 
 ## Installation
 
+### For New Projects
+
 ```bash
-npm install @kya-os/mcp-i
+npx @kya-os/create-xmcpi-app@latest my-agent
 ```
 
-## Quick Start
+### For Existing Projects
+
+```bash
+npm install @kya-os/xmcpi
+# or
+yarn add @kya-os/xmcpi
+# or
+pnpm add @kya-os/xmcpi
+```
+
+## Migrating from XMCP
 
-### 1. Zero Configuration (Recommended)
+Your existing XMCP agents can gain ownership capabilities:
 
 ```typescript
-import "@kya-os/mcp-i/auto";
-// That's it! Your server now has cryptographic identity
+// Before (original XMCP - platform owned)
+import { createXMCPServer } from "xmcp";
+
+// After (XMCP-I - you own the agent!)
+import { createXMCPServer } from "xmcp-i";
 ```
 
-### 2. With Progress Tracking (CLI Tools)
+Your existing code works unchanged, but now your agent:
 
-```typescript
-import { enableMCPIdentity } from "@kya-os/mcp-i";
+- ✅ Has its own cryptographic identity
+- ✅ Can be registered and claimed by you at knowthat.ai
+- ✅ Signs all responses automatically
+- ✅ Supports secure permission delegation
+- ✅ Provides verifiable ownership proof
+
+## Core Identity Features
+
+### Agent Identity Verification
+
+Your agent provides cryptographic proof of ownership:
 
-const identity = await enableMCPIdentity({
-  name: "My CLI Tool",
-  // Progress callback automatically triggers fast CLI endpoint (100-200ms)
-  onProgress: (event) => {
-    console.log(`${event.stage}: ${event.message}`);
+```bash
+# Your agent's identity includes:
+{
+  "did": "did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK",
+  "publicKey": "-----BEGIN PUBLIC KEY-----\n...",
+  "privateKey": "-----BEGIN PRIVATE KEY-----\n...",  // Never shared
+  "agentId": "agent-abc123...",
+  "capabilities": {
+    "tools": true,
+    "signing": true,
+    "verification": true,
+    "delegation": true
   }
-});
+}
 ```
 
-### 3. Production Configuration
+- **Public Key**: Can be shared and verified by anyone
+- **Private Key**: Never leaves your control, stored securely locally
+- **DID**: Globally unique identifier generated from your public key
+- **Signatures**: All agent responses include cryptographic signatures
 
-```typescript
-import { enableMCPIdentity } from "@kya-os/mcp-i";
+### Trust Infrastructure
+
+- `GET /.well-known/mcp-identity/health` - Health check with identity
+- `GET /.well-known/mcp-identity/self` - Agent identity information
+- `POST /.well-known/mcp-identity/verify` - Verify signatures
+- `GET /.well-known/mcp-identity/resolve/:did` - Resolve DIDs
 
-const identity = await enableMCPIdentity({
-  name: "Production Agent",
+### Built-in Identity Tools & Self-Sovereign Features
 
-  // Auto-detect runtime (Lambda, Edge, Node.js)
-  storage: "auto",
-  transport: "auto",
+- `get-identity-info` - Comprehensive agent identity details
+- `sign-message` - Sign messages with your private key
+- `verify-signature` - Verify signatures against DIDs
+- `get-server-status` - Agent status with identity information
+- `get-user-data` - Allow users to see all stored data about them
+- `revoke-user-access` - Let users instantly revoke AI access to their data
+- `export-user-data` - Enable users to export their data for portability
 
-  // Encrypt private keys at rest
-  encryptionPassword: process.env.AGENT_KEY_PASSWORD,
+## Secure Permission Delegation
 
-  // Professional logging
-  logLevel: "error", // or 'silent' for production
+Control what your agent can do and for whom:
 
-  // Directory preferences (optional)
-  directories: "verified", // List on all verified directories
-  // OR directories: ["smithery", "glama"] // Specific directories
-  // OR directories: "none" // No directory listings
+```typescript
+// Delegate specific permissions to other DIDs
+await agent.delegate({
+  to: "did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK",
+  permissions: ["read:data", "execute:safe-actions"],
+  expires: new Date("2025-12-31"),
+  conditions: {
+    rate_limit: "100/hour",
+    allowed_tools: ["get-weather", "search-docs"],
+  },
 });
 
-// Enable automatic key rotation
-await identity.enableAutoRotation({
-  maxAge: 90 * 24 * 60 * 60 * 1000, // 90 days
-  maxSignatures: 1_000_000, // 1M signatures
+// Revoke permissions instantly
+await agent.revoke({
+  delegation_id: "del_abc123",
+  reason: "Project completed",
 });
+
+// All delegation changes are cryptographically signed and verifiable
 ```
 
-### 3. Lambda/Edge Runtime
+### Secure Delegation Example
+
+Grant specific permissions to other users while maintaining ownership:
 
 ```typescript
-// Automatic configuration for serverless
-const identity = await enableMCPIdentity({
-  name: "Serverless Agent",
-  storage: "memory", // No file system needed
-  transport: "fetch", // Native fetch for edge
-  logLevel: "silent", // No console output
+// Example: Grant read-only access to specific tools
+await agent.delegate({
+  to: "user@example.com",
+  permissions: ["read:weather", "read:docs"],
+  expires: "2025-12-31T23:59:59Z",
+  conditions: { rate_limit: "100/hour" },
 });
 ```
 
-## Production Features
+## Platform Support with Identity Persistence
 
-### Performance Optimizations
+Deploy your owned agents anywhere with secure identity storage:
 
-- **Lazy Loading**: Crypto libraries load only when needed
-- **Signature Caching**: Repeated signatures are 10x faster
-- **Precomputed Values**: DIDs and keys cached in memory
-- **Optimized Transport**: Auto-selects axios vs fetch
+### Vercel
 
-### Security Features
+- **Edge Runtime**: Fast cold starts with identity context
+- **KV Storage**: Secure identity persistence using Vercel KV
+- **Zero Config**: Deploy with `vercel --prod` and identity works
+- **Environment**: Automatic identity configuration and key management
 
-- **Key Encryption**: Private keys encrypted with AES-256-GCM
-- **Key Rotation**: Automatic rotation based on age/usage
-- **Nonce Tracking**: Prevents replay attacks
-- **Timestamp Validation**: Configurable tolerance windows
+### AWS Lambda
 
-### Runtime Support
+- **Cold Start Optimized**: Minimal initialization with cached identity
+- **DynamoDB**: Secure identity storage with DynamoDB persistence
+- **Serverless**: Built-in serverless framework configuration
+- **IAM Integration**: Pre-configured identity and permission policies
 
-- **AWS Lambda**: Automatic memory storage
-- **Vercel Edge**: Native fetch transport
-- **Cloudflare Workers**: Full compatibility
-- **Node.js**: Traditional file storage
+### Next.js
 
-### Directory Listings
+- **API Routes**: Identity-enabled API endpoints out of the box
+- **Middleware**: Request-level identity verification and delegation
+- **SSR Support**: Server-side identity rendering and verification
+- **Full Stack**: Complete client and server identity integration
 
-```typescript
-// Configure directory listings
-await enableMCPIdentity({
-  name: "My Agent",
+### Express
 
-  // Option 1: List on all verified directories
-  directories: "verified",
+- **Middleware Stack**: Identity verification middleware for existing apps
+- **Flexible Routing**: Identity-aware route handlers and permission checking
+- **Production Ready**: Battle-tested middleware for production workloads
+- **Custom Auth**: Extensible identity providers and authentication flows
 
-  // Option 2: List on specific directories
-  directories: ["smithery", "glama"],
+### Standalone
 
-  // Option 3: No directory listings (registry only)
-  directories: "none",
-});
+- **File Persistence**: Local identity storage with file-based backend
+- **Docker Ready**: Containerized deployment with identity intact
+- **Self Hosted**: Complete control over your agent and its identity
+- **Process Management**: PM2 and systemd configurations included
+
+## CLI Usage
+
+```bash
+# Development with identity features
+xmcp-i dev
 
-// Directory preferences are sent to knowthat.ai
-// The registry handles submissions to your chosen directories
+# Build for production deployment
+mcpi build
+
+# Platform-specific builds with identity optimization
+mcpi build --vercel
+mcpi build --lambda
+mcpi build --docker
 ```
 
-## Advanced Usage
+## Framework Integration
 
-### Key Rotation
+### Agent Ownership in Action
 
 ```typescript
-// Check key health
-const health = identity.checkKeyHealth();
-console.log(`Key age: ${health.age}ms`);
-console.log(`Signatures: ${health.signatureCount}`);
-console.log(`Should rotate: ${health.shouldRotate}`);
-
-// Manual rotation
-const result = await identity.rotateKeys("security-policy");
-if (result.success) {
-  console.log(`Grace period ends: ${result.gracePeriodEnd}`);
-}
+import { createXMCPServer } from "@kya-os/xmcpi";
+
+// Create an agent with built-in cryptographic identity
+const agent = await createXMCPServer({
+  name: "my-personal-agent",
+  identity: {
+    // Identity generated automatically with Ed25519 keys
+    autoSign: true, // All responses signed with your key
+    trustEndpoints: true, // Verification endpoints enabled
+    persistence: "file", // Store identity securely
+  },
+  tools: [
+    {
+      name: "secure-action",
+      description: "Execute action with verified identity",
+      parameters: { action: { type: "string", required: true } },
+      handler: async ({ action }, context) => {
+        // Every response includes your cryptographic signature
+        return {
+          action: `Executed: ${action}`,
+          agent_did: context.server.identity.did,
+          owner: "you@knowthat.ai",
+          timestamp: new Date().toISOString(),
+          // ↑ This response is automatically signed with your private key
+        };
+      },
+    },
+  ],
+});
+
+// Register your agent's DID with knowthat.ai to claim ownership
+await agent.register("https://knowthat.ai");
 
-// Automatic rotation
-await identity.enableAutoRotation({
-  maxAge: 30 * 24 * 60 * 60 * 1000, // 30 days
-  maxSignatures: 500_000, // 500k signatures
+agent.listen(3000, () => {
+  console.log(`🤖 Your agent is running: ${agent.identity.did}`);
+  console.log(
+    `🔐 Claim ownership: https://knowthat.ai/claim/${agent.identity.did}`
+  );
 });
 ```
 
-### Edit/Claim URLs
+## Migrating from XMCP
 
-```typescript
-// Get signed URLs for editing
-const { editUrl, claimUrl } = await identity.requestEditAccess();
+Your existing XMCP agents can gain ownership capabilities:
 
-// Edit URL - for existing agents
-console.log("Edit your agent:", editUrl);
+```typescript
+// Before (original XMCP - platform owned)
+import { createXMCPServer } from "xmcp";
 
-// Claim URL - for draft/unclaimed agents
-console.log("Claim your agent:", claimUrl);
+// After (XMCP-I - you own the agent!)
+import { createXMCPServer } from "xmcp-i";
 ```
 
-### Custom Storage
+Your existing code works unchanged, but now your agent:
+
+- ✅ Has its own cryptographic identity
+- ✅ Can be registered and claimed by you at knowthat.ai
+- ✅ Signs all responses automatically
+- ✅ Supports secure permission delegation
+- ✅ Provides verifiable ownership proof
+
+## Advanced Identity Features
+
+### Custom Identity Providers
 
 ```typescript
-// Encrypted file storage
-await enableMCPIdentity({
-  storage: "file",
-  persistencePath: "/secure/location/.identity",
-  encryptionPassword: "strong-password",
+import { createCustomIdentityProvider } from "@kya-os/xmcpi/platforms";
+
+const customProvider = createCustomIdentityProvider({
+  keyType: "secp256k1", // Alternative key types
+  generateDID: (pubKey) => `did:custom:${hash(pubKey)}`,
+  persistence: "redis", // Custom storage backends
+  knowthat: {
+    apiKey: process.env.KNOWTHAT_API_KEY,
+    autoRegister: true, // Automatic agent registration
+  },
 });
 
-// Memory storage with custom key
-await enableMCPIdentity({
-  storage: "memory",
-  memoryKey: "agent-123", // Useful for multiple agents
+const agent = await createXMCPServer({
+  name: "my-custom-agent",
+  identity: { provider: customProvider },
 });
 ```
 
-### Custom Logger
+### Identity Middleware Integration
 
 ```typescript
-await enableMCPIdentity({
-  logger: {
-    debug: (msg, ...args) => myLogger.debug(msg, args),
-    info: (msg, ...args) => myLogger.info(msg, args),
-    warn: (msg, ...args) => myLogger.warn(msg, args),
-    error: (msg, ...args) => myLogger.error(msg, args),
-  },
+import { identityMiddleware, delegationMiddleware } from "@kya-os/xmcpi";
+
+const agent = await createXMCPServer({
+  name: "my-secure-agent",
+  middlewares: [
+    identityMiddleware({
+      requireSignature: true, // Require signed requests
+      trustLevel: "verified", // Only accept verified DIDs
+    }),
+    delegationMiddleware({
+      checkPermissions: true, // Validate delegated permissions
+      rateLimiting: true, // Enforce delegation rate limits
+    }),
+  ],
 });
 ```
 
-## API Reference
+## Dependencies and Architecture
 
-### `enableMCPIdentity(options?)`
+XMCP-I builds on proven cryptographic foundations:
 
-Main function to enable identity for your MCP server.
+### Core Identity Stack
 
-**Options:**
+- **@kya-os/mcp-i** - Core identity protocol implementation with knowthat.ai integration
+- **jose** - JWT and cryptographic operations (JWS, JWE, JWK)
+- **@modelcontextprotocol/sdk** - MCP protocol SDK for agent communication
+- **axios** - HTTP client for identity resolution and knowthat.ai API calls
 
-```typescript
-interface MCPIdentityOptions {
-  // Basic info
-  name?: string;
-  description?: string;
-  repository?: string;
-
-  // Storage
-  storage?: "file" | "memory" | "auto";
-  persistencePath?: string;
-  memoryKey?: string;
-  encryptionPassword?: string;
-
-  // Transport
-  transport?: "axios" | "fetch" | "auto";
-
-  // Security
-  timestampTolerance?: number; // Default: 60000ms
-  enableNonceTracking?: boolean; // Default: true
-
-  // Directory listings
-  directories?: string[] | "verified" | "none"; // Default: "verified"
-
-  // Development
-  mode?: "development" | "production";
-
-  // Logging
-  logger?: Logger;
-  logLevel?: "debug" | "info" | "warn" | "error" | "silent";
-}
-```
+### Development Stack
 
-### `MCPIdentity` Methods
+- **express** - Web server framework for identity endpoints
+- **webpack** - Module bundler with identity-aware compilation
+- **chalk** - Beautiful CLI output for identity operations
+- **chokidar** - File watching with identity file monitoring
 
-- `sign(message)`: Sign with caching
-- `verify(message, signature, publicKey?)`: Verify signatures
-- `respondToChallenge(challenge)`: MCP-I authentication
-- `signResponse(response)`: Add identity to responses
-- `requestEditAccess()`: Get edit/claim URLs
-- `rotateKeys(reason?)`: Manual key rotation
-- `enableAutoRotation(policy?)`: Automatic rotation
-- `checkKeyHealth()`: Key rotation status
+### Cryptographic Security
 
-## Files Created
+- **Ed25519** - Elliptic curve digital signatures (default)
+- **secp256k1** - Bitcoin-compatible signatures (optional)
+- **DID Keys** - Decentralized identifier generation from public keys
+- **JWS/JWE** - JSON Web Signatures and Encryption for secure transport
 
-```
-.mcp-identity.json    # Your agent's identity (encrypted if password set)
-```
+## Development
 
-## Security Best Practices
+Build your own identity-enabled MCP agents:
 
-1. **Use encryption in production**: Always set `encryptionPassword`
-2. **Enable key rotation**: Set up automatic rotation policies
-3. **Secure storage**: Use appropriate file permissions
-4. **Monitor key health**: Check rotation status regularly
-5. **Add to .gitignore**: Never commit identity files
+```bash
+# Clone the repository
+git clone https://github.com/modelcontextprotocol-identity/xmcp-i.git
 
-## Performance Tips
+# Install dependencies
+pnpm install
 
-1. **Use memory storage** for Lambda/Edge runtimes
-2. **Enable signature caching** (automatic)
-3. **Use 'silent' log level** in production
-4. **Let transport auto-select** based on runtime
-5. **Preload identity** during cold starts
+# Start development with identity features
+pnpm run dev
 
-## Troubleshooting
+# Build for production with identity optimization
+pnpm run build
 
-### Lambda/Edge Issues
+# Run identity-aware tests
+pnpm run test
 
-- Ensure `storage: 'memory'` or `'auto'`
-- Use `transport: 'fetch'` for edge runtimes
-- Set `logLevel: 'silent'` to avoid console issues
+# Lint code including identity modules
+pnpm run lint
+```
 
-### Key Rotation Failures
+## Learn more
 
-- Check network connectivity to knowthat.ai
-- Verify current keys are not corrupted
-- Manual rotation: `await identity.rotateKeys('recovery')`
+⊹ **Register Your Agent**: [knowthat.ai](https://knowthat.ai) - Claim ownership of your AI agents\
+⊹ **Original XMCP Framework**: [xmcp.dev](https://xmcp.dev) - Base framework documentation\
+⊹ **Model Context Protocol**: [modelcontextprotocol.io](https://modelcontextprotocol.io) - Core protocol specification
 
-### Performance Issues
+## Security
 
-- Verify signature caching is working
-- Check lazy loading (should see delayed first signature)
-- Use memory storage when possible
+If you believe you have found a security vulnerability, please report it to [security@xmcp-i.dev](mailto:security@xmcp-i.dev). We take agent ownership security seriously and will investigate all reports promptly.
 
 ## License
 
-MIT
+This project is licensed under the MIT License - see the [LICENSE](https://github.com/modelcontextprotocol-identity/xmcp-i/blob/main/license.md) file for details.