Identity Layer for Model Context Protocol

import { MCPClientAdapter } from '@private.me/mcp-transport';
import { generateIdentity } from '@private.me/xlink';

const client = new MCPClientAdapter({
  implementation: { name: 'my-agent', version: '1.0' },
  capabilities: { tools: {} },
  transport: {
    identity: await generateIdentity(),
    peerDid: 'did:key:z6Mk...',
    policy: { maxCallsPerHour: 100 }
  }
});

await client.connect();
const tools = await client.listTools();
const result = await client.callTool('payment', { to: 'alice', amount: 100 });

import { MCPServerAdapter } from '@private.me/mcp-transport';
import { generateIdentity } from '@private.me/xlink';

const server = new MCPServerAdapter({
  implementation: { name: 'payment-server', version: '1.0' },
  capabilities: { tools: { listChanged: true } },
  transport: {
    identity: await generateIdentity(),
    peerDid: 'did:key:z6Mk...'
  }
});

server.registerTool({
  name: 'payment',
  description: 'Send payment',
  inputSchema: { /* ... */ }
}, async (args) => {
  // Process payment
  return { success: true };
});

await server.start();

// Every agent uses the same API key
const agents = await Promise.all(
  Array.from({ length: 500 }, (_, i) =>
    createAgent({
      id: `agent-${i}`,
      apiKey: process.env.API_KEY // Same key for all 500
    })
  )
);

// Problems:
//  One compromised agent → rotate key → 500 agents offline
//  Can't identify which agent made which request
//  Can't rate-limit per-agent (all share quota)

// Each agent generates unique cryptographic identity
const agents = await Promise.all(
  Array.from({ length: 500 }, async (_, i) => {
    const client = new MCPClientAdapter({
      implementation: { name: `agent-${i}`, version: '1.0' },
      capabilities: { tools: {} },
      transport: {
        identity: await generateIdentity(),
        peerDid: serverDid
      }
    });
    return client;
  })
);

// Benefits:
//  One compromised agent → remove from trust registry → 499 continue
//  Cryptographic attribution per message
//  Per-agent rate limits enforced independently

https://private.me/subscribe?product=mcp-transport

POST /api/purchase
Content-Type: application/json

{
  "product": "mcp-transport",
  "tier": "basic",
  "email": "customer@example.com",
  "customerId": "cus_abc123"
}

{
  "subscriptionId": "sub_xyz789",
  "status": "active",
  "trialEnd": "2026-07-28T00:00:00Z",
  "product": "mcp-transport",
  "tier": "basic"
}

{
  "type": "https://private.me/errors/validation-failed",
  "title": "Validation Failed",
  "status": 400,
  "detail": "Request validation failed",
  "instance": "/api/purchase",
  "fields": {
    "email": "Invalid email format",
    "tier": "Must be one of: basic, middle, enterprise"
  }
}

const transport = new XLinkTransport({
  identity: myIdentity,
  peerDid: serverDid,
  policy: {
    allow: ['tools/call', 'tools/list'],
    deny: ['admin/*'],
    maxCallsPerHour: 100,
    maxCallsPerDay: 1000,
    customValidator: async (message) => {
      // Custom business logic
      return ok(undefined);
    }
  }
});

npm install @private.me/mcp-transport

const client = new MCPClient({
  transport: new HttpTransport('https://api.example.com')
});

const client = new MCPClientAdapter({
  implementation: { name: 'my-client', version: '1.0' },
  capabilities: { tools: {} },
  transport: {
    identity: await generateIdentity(),
    peerDid: 'did:key:z6Mk...'
  }
});