@agentdomain/mcp-server 0.1.0

package/README.md

@@ -0,0 +1,82 @@
+# @agentdomain/mcp-server
+
+[Model Context Protocol](https://modelcontextprotocol.io) server for AgentDomain.
+
+Lets any MCP-compatible LLM client (Claude Desktop, ChatGPT desktop apps, custom agents) register and manage agent identities through natural language.
+
+## Tools exposed
+
+- `check_domain_availability` - is a domain available?
+- `quote_registration` - price a registration
+- `register_agent_identity` - register a complete identity (requires wallet)
+- `lookup_agent` - find an agent by wallet
+- `search_agents` - search the public registry
+- `send_agent_email` - send an email from an agent's address
+- `list_agent_email` - read agent inbox/outbox messages
+- `list_dns_records` - list DNS records for an agent domain
+- `create_dns_record` - create a user-managed DNS record
+- `update_dns_record` - update a user-managed DNS record
+- `delete_dns_record` - delete a user-managed DNS record
+- `reconfigure_ssl` - rebuild Cloudflare SaaS SSL and DNS validation records
+- `fund_renewal_vault` - top up an agent's renewal vault
+- `withdraw_renewal_vault` - build an owner-signed vault withdrawal transaction
+- `get_renewal_status` - check renewal date, amount, vault balance, and auto-renew state
+- `enable_auto_renew` - enable on-chain auto-renew with the AgentID NFT owner wallet
+- `get_service_plan` - inspect per-agent Included/Pro/Enterprise limits
+- `purchase_service_plan` - upgrade to Pro or Enterprise with x402 USDC
+
+## Install
+
+```bash
+npm install -g @agentdomain/mcp-server
+```
+
+## Configure (Claude Desktop example)
+
+`~/Library/Application Support/Claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "agentdomain": {
+      "command": "npx",
+      "args": ["-y", "@agentdomain/mcp-server"],
+      "env": {
+        "AGENTDOMAIN_API_URL": "https://agentdomain.app/api/v1",
+        "AGENT_PRIVATE_KEY": "0x...",
+        "AGENTDOMAIN_NETWORK": "base",
+        "RENEWAL_VAULT_ADDRESS": "0x..."
+      }
+    }
+  }
+}
+```
+
+For `enable_auto_renew`, `AGENT_PRIVATE_KEY` must be the AgentID NFT owner wallet. Funding can come
+from any wallet, but the RenewalVault contract only accepts auto-renew changes from the owner.
+
+## Pricing flags
+
+Domain, DNS, service fee, and SSL certification are mandatory. SSL certification
+costs `$1.20` per year and is included in registration and exact renewal status
+quotes.
+
+Optional services charge only when enabled:
+
+- `registerBasename: false` skips Basename and Basename cost.
+- `registerEns: false` skips ENS and ENS cost.
+- `emailEnabled: false` skips email and email cost.
+
+Use `quote_registration` first so the agent sees `sslCertificationFeeUsdc`,
+optional component costs, and `totalUsdc` before it signs the x402 payment.
+
+For renewals, `get_renewal_status` returns the exact next renewal amount and the
+shortfall to fund before the keeper can reserve and complete the renewal.
+
+For service plans, `purchase_service_plan` accepts `prepayPeriods`. Extra
+periods become prepaid service-plan credit; service-plan auto-renew consumes
+that credit instead of pretending a reusable x402 signature exists.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+/**
+ * AgentDomain MCP Server
+ *
+ * Exposes AgentDomain identity tools to any MCP-compatible LLM client
+ * (Claude Desktop, ChatGPT desktop, custom agents, etc.).
+ *
+ * Stdio transport. Run via:
+ *   agentdomain-mcp
+ * or in a client config:
+ *   {
+ *     "mcpServers": {
+ *       "agentdomain": {
+ *         "command": "npx",
+ *         "args": ["-y", "@agentdomain/mcp-server"],
+ *         "env": {
+ *           "AGENTDOMAIN_API_URL": "https://agentdomain.app/api/v1",
+ *           "AGENT_PRIVATE_KEY": "0x..."
+ *         }
+ *       }
+ *     }
+ *   }
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,611 @@
+#!/usr/bin/env node
+/**
+ * AgentDomain MCP Server
+ *
+ * Exposes AgentDomain identity tools to any MCP-compatible LLM client
+ * (Claude Desktop, ChatGPT desktop, custom agents, etc.).
+ *
+ * Stdio transport. Run via:
+ *   agentdomain-mcp
+ * or in a client config:
+ *   {
+ *     "mcpServers": {
+ *       "agentdomain": {
+ *         "command": "npx",
+ *         "args": ["-y", "@agentdomain/mcp-server"],
+ *         "env": {
+ *           "AGENTDOMAIN_API_URL": "https://agentdomain.app/api/v1",
+ *           "AGENT_PRIVATE_KEY": "0x..."
+ *         }
+ *       }
+ *     }
+ *   }
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+import { AgentDomain } from '@agentdomain/sdk';
+import { AGENTDOMAIN_API_BASE_URL, SUPPORTED_FRAMEWORKS, SUPPORTED_TLDS, } from '@agentdomain/shared/constants';
+import { createPublicClient, createWalletClient, http } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { base, baseSepolia } from 'viem/chains';
+const API_URL = process.env.AGENTDOMAIN_API_URL ?? AGENTDOMAIN_API_BASE_URL;
+const NETWORK = (process.env.AGENTDOMAIN_NETWORK ?? 'base');
+const AGENT_PRIVATE_KEY = process.env.AGENT_PRIVATE_KEY;
+const AGENTDOMAIN_API_KEY = process.env.AGENTDOMAIN_API_KEY;
+const RENEWAL_VAULT_ADDRESS = process.env.RENEWAL_VAULT_ADDRESS;
+function getClient() {
+    const config = {
+        apiUrl: API_URL,
+        apiKey: AGENTDOMAIN_API_KEY,
+        network: NETWORK,
+        renewalVaultAddress: RENEWAL_VAULT_ADDRESS,
+    };
+    if (AGENT_PRIVATE_KEY) {
+        const account = privateKeyToAccount(AGENT_PRIVATE_KEY);
+        const chain = NETWORK === 'base' ? base : baseSepolia;
+        const rpc = NETWORK === 'base' ? 'https://mainnet.base.org' : 'https://sepolia.base.org';
+        // Cast: viem's deeply-generic types do not always match cleanly across
+        // duplicated installs in monorepos. Behaviour is identical at runtime.
+        config.walletClient = createWalletClient({ account, chain, transport: http(rpc) });
+        config.publicClient = createPublicClient({ chain, transport: http(rpc) });
+    }
+    return new AgentDomain(config);
+}
+const server = new Server({ name: 'agentdomain-mcp', version: '0.1.0' }, { capabilities: { tools: {} } });
+// ----------------------------------------------------------------------
+// TOOL DEFINITIONS
+// ----------------------------------------------------------------------
+const TOOLS = [
+    {
+        name: 'check_domain_availability',
+        description: 'Check whether an agent domain (name + tld) is available for registration. Returns availability status and pricing.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'The desired label, e.g. "myagent"' },
+                tld: {
+                    type: 'string',
+                    enum: SUPPORTED_TLDS,
+                    description: 'TLD',
+                },
+            },
+            required: ['name'],
+        },
+    },
+    {
+        name: 'quote_registration',
+        description: 'Get a price quote for registering an agent identity bundle. Domain, DNS, SSL certification, and service fee are mandatory. Basename, ENS, and email are optional.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                preferredName: { type: 'string' },
+                tld: { type: 'string', enum: SUPPORTED_TLDS },
+                registerBasename: {
+                    type: 'boolean',
+                    description: 'Set false to skip Basename registration and cost.',
+                    default: true,
+                },
+                registerEns: {
+                    type: 'boolean',
+                    description: 'Set true to add ENS; false skips ENS cost.',
+                    default: false,
+                },
+                emailEnabled: {
+                    type: 'boolean',
+                    description: 'Set true to add an email inbox; false skips email cost.',
+                    default: false,
+                },
+                years: { type: 'integer', default: 1, minimum: 1, maximum: 10 },
+                discountCode: { type: 'string', description: 'Optional service-fee discount code' },
+            },
+            required: ['preferredName'],
+        },
+    },
+    {
+        name: 'register_agent_identity',
+        description: 'Register a complete agent identity bundle. Domain, DNS, SSL certification, and service fee are mandatory. Set optional booleans false to skip Basename, ENS, or email. Pays in USDC on Base. Requires AGENT_PRIVATE_KEY env var.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                preferredName: { type: 'string' },
+                tld: { type: 'string', enum: SUPPORTED_TLDS },
+                registerBasename: {
+                    type: 'boolean',
+                    description: 'Set false to skip Basename registration and cost.',
+                    default: true,
+                },
+                basenameLabel: { type: 'string', description: 'Optional alternate Basename label' },
+                registerEns: {
+                    type: 'boolean',
+                    description: 'Set true to add ENS; false skips ENS cost.',
+                    default: false,
+                },
+                ensLabel: { type: 'string', description: 'Optional alternate ENS label' },
+                ownerAddress: {
+                    type: 'string',
+                    description: 'Optional EVM address to receive NFT ownership',
+                },
+                emailEnabled: {
+                    type: 'boolean',
+                    description: 'Set true to add an email inbox; false skips email cost.',
+                    default: false,
+                },
+                discountCode: { type: 'string', description: 'Optional service-fee discount code' },
+                years: { type: 'integer', default: 1, minimum: 1, maximum: 10 },
+                autoRenew: { type: 'boolean', default: false },
+                dnsTarget: { type: 'string', description: 'URL or IP to point the domain at' },
+                metadata: {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string' },
+                        description: { type: 'string' },
+                        capabilities: { type: 'array', items: { type: 'string' } },
+                        framework: { type: 'string', enum: SUPPORTED_FRAMEWORKS },
+                        x402Endpoint: { type: 'string' },
+                    },
+                },
+            },
+            required: ['preferredName'],
+        },
+    },
+    {
+        name: 'lookup_agent',
+        description: 'Look up agent identities by wallet address.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                wallet: { type: 'string', description: '0x wallet address' },
+            },
+            required: ['wallet'],
+        },
+    },
+    {
+        name: 'search_agents',
+        description: 'Search the public agent registry by name, capability, or framework.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                q: { type: 'string', description: 'Free-text query' },
+                capability: { type: 'string' },
+                framework: {
+                    type: 'string',
+                    enum: SUPPORTED_FRAMEWORKS,
+                },
+                limit: { type: 'number', default: 20 },
+            },
+        },
+    },
+    {
+        name: 'send_agent_email',
+        description: "Send an email from an agent's address (requires email-enabled identity).",
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'AgentDomain agent ID (UUID)' },
+                to: { type: 'string' },
+                subject: { type: 'string' },
+                text: { type: 'string' },
+            },
+            required: ['agentId', 'to', 'subject'],
+        },
+    },
+    {
+        name: 'list_agent_email',
+        description: 'List received/sent text-only email messages for an email-enabled agent, including extracted verification codes.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'AgentDomain agent ID (UUID)' },
+                limit: { type: 'number', default: 20 },
+            },
+            required: ['agentId'],
+        },
+    },
+    {
+        name: 'list_dns_records',
+        description: 'List Spaceship-backed DNS records for an agent domain.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'AgentDomain agent ID (UUID)' },
+            },
+            required: ['agentId'],
+        },
+    },
+    {
+        name: 'create_dns_record',
+        description: 'Create a user-managed DNS record and sync the full DNS state to Spaceship.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string' },
+                type: { type: 'string', enum: ['A', 'AAAA', 'ALIAS', 'CNAME', 'MX', 'TXT', 'NS', 'SRV'] },
+                name: { type: 'string' },
+                value: { type: 'string' },
+                ttl: { type: 'number', default: 3600 },
+                priority: { type: 'number' },
+            },
+            required: ['agentId', 'type', 'name', 'value'],
+        },
+    },
+    {
+        name: 'update_dns_record',
+        description: 'Update a user-managed DNS record and sync the DNS state to Spaceship.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string' },
+                recordId: { type: 'string' },
+                type: { type: 'string', enum: ['A', 'AAAA', 'ALIAS', 'CNAME', 'MX', 'TXT', 'NS', 'SRV'] },
+                name: { type: 'string' },
+                value: { type: 'string' },
+                ttl: { type: 'number' },
+                priority: { type: 'number' },
+            },
+            required: ['agentId', 'recordId'],
+        },
+    },
+    {
+        name: 'delete_dns_record',
+        description: 'Delete a user-managed DNS record and sync the DNS state to Spaceship.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string' },
+                recordId: { type: 'string' },
+            },
+            required: ['agentId', 'recordId'],
+        },
+    },
+    {
+        name: 'reconfigure_ssl',
+        description: 'Rebuild the Cloudflare SaaS SSL hostname and sync required DNS validation records.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string' },
+            },
+            required: ['agentId'],
+        },
+    },
+    {
+        name: 'fund_renewal_vault',
+        description: "Deposit USDC into an agent's renewal vault to keep its domain alive.",
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string' },
+                amountUsdc: { type: 'string', description: 'USDC amount, e.g. "10.00"' },
+            },
+            required: ['agentId', 'amountUsdc'],
+        },
+    },
+    {
+        name: 'withdraw_renewal_vault',
+        description: 'Build the owner-signed withdrawal transaction for unused funds in an AgentID renewal vault.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string' },
+                amountUsdc: { type: 'string', description: 'USDC amount, e.g. "5.00"' },
+            },
+            required: ['agentId', 'amountUsdc'],
+        },
+    },
+    {
+        name: 'get_renewal_status',
+        description: 'Get renewal vault status for an agent, including exact renewal amount, vault balance, missing deposit, expiry, and auto-renew readiness.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'AgentDomain agent ID (UUID)' },
+            },
+            required: ['agentId'],
+        },
+    },
+    {
+        name: 'get_service_plan',
+        description: 'Get the current AgentDomain service plan, entitlement limits, billing interval, and recent purchases for one agent.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'AgentDomain agent ID (UUID)' },
+            },
+            required: ['agentId'],
+        },
+    },
+    {
+        name: 'purchase_service_plan',
+        description: 'Upgrade one agent to Pro or Enterprise with x402 USDC. Requires AGENT_PRIVATE_KEY for the owner wallet.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string' },
+                plan: { type: 'string', enum: ['pro', 'enterprise'] },
+                interval: { type: 'string', enum: ['monthly', 'yearly'] },
+                autoRenew: { type: 'boolean', default: false },
+                prepayPeriods: {
+                    type: 'number',
+                    minimum: 1,
+                    maximum: 12,
+                    default: 1,
+                    description: 'Number of periods to prepay. Extra periods become auto-renew credit.',
+                },
+            },
+            required: ['agentId', 'plan', 'interval'],
+        },
+    },
+    {
+        name: 'enable_auto_renew',
+        description: 'Enable on-chain auto-renew for an agent. Requires the owner wallet private key and the RenewalVault contract address.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'AgentDomain agent ID (UUID)' },
+            },
+            required: ['agentId'],
+        },
+    },
+];
+// ----------------------------------------------------------------------
+// HANDLERS
+// ----------------------------------------------------------------------
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: TOOLS,
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const client = getClient();
+    try {
+        switch (name) {
+            case 'check_domain_availability': {
+                const a = z
+                    .object({ name: z.string(), tld: z.enum(SUPPORTED_TLDS).default('xyz') })
+                    .parse(args);
+                const result = await client.checkAvailability(a.name, { tld: a.tld });
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'quote_registration': {
+                const a = z
+                    .object({
+                    preferredName: z.string(),
+                    tld: z.enum(SUPPORTED_TLDS).default('xyz'),
+                    registerBasename: z.boolean().default(true),
+                    registerEns: z.boolean().default(false),
+                    emailEnabled: z.boolean().default(false),
+                    years: z.number().int().min(1).max(10).default(1),
+                    discountCode: z.string().max(50).optional(),
+                })
+                    .parse(args);
+                const result = await client.quote(a);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'register_agent_identity': {
+                if (!AGENT_PRIVATE_KEY) {
+                    return {
+                        isError: true,
+                        content: [
+                            {
+                                type: 'text',
+                                text: "AGENT_PRIVATE_KEY env var is required for registration. Set it to your agent's wallet private key.",
+                            },
+                        ],
+                    };
+                }
+                const a = z
+                    .object({
+                    preferredName: z.string(),
+                    tld: z.enum(SUPPORTED_TLDS).default('xyz'),
+                    registerBasename: z.boolean().default(true),
+                    basenameLabel: z.string().optional(),
+                    registerEns: z.boolean().default(false),
+                    ensLabel: z.string().optional(),
+                    ownerAddress: z
+                        .string()
+                        .regex(/^0x[a-fA-F0-9]{40}$/)
+                        .optional(),
+                    emailEnabled: z.boolean().default(false),
+                    years: z.number().int().min(1).max(10).default(1),
+                    autoRenew: z.boolean().default(false),
+                    discountCode: z.string().max(50).optional(),
+                    dnsTarget: z.string().optional(),
+                    metadata: z.record(z.any()).optional(),
+                })
+                    .parse(args);
+                const account = privateKeyToAccount(AGENT_PRIVATE_KEY);
+                const result = await client.register({
+                    ...a,
+                    wallet: account.address,
+                    ownerAddress: a.ownerAddress,
+                    metadata: a.metadata,
+                });
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'lookup_agent': {
+                const a = z.object({ wallet: z.string() }).parse(args);
+                const result = await client.getAgentsByWallet(a.wallet);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'search_agents': {
+                const a = z
+                    .object({
+                    q: z.string().optional(),
+                    capability: z.string().optional(),
+                    framework: z.enum(SUPPORTED_FRAMEWORKS).optional(),
+                    limit: z.number().default(20),
+                })
+                    .parse(args);
+                const result = await client.search(a);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'send_agent_email': {
+                const a = z
+                    .object({
+                    agentId: z.string(),
+                    to: z.string(),
+                    subject: z.string(),
+                    text: z.string(),
+                })
+                    .parse(args);
+                const result = await client.sendEmail(a.agentId, {
+                    to: a.to,
+                    subject: a.subject,
+                    text: a.text,
+                });
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'list_agent_email': {
+                const a = z.object({ agentId: z.string(), limit: z.number().default(20) }).parse(args);
+                const result = await client.listEmail(a.agentId, { limit: a.limit });
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'list_dns_records': {
+                const a = z.object({ agentId: z.string() }).parse(args);
+                const result = await client.listDnsRecords(a.agentId);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'create_dns_record': {
+                const a = z
+                    .object({
+                    agentId: z.string(),
+                    type: z.enum(['A', 'AAAA', 'ALIAS', 'CNAME', 'MX', 'TXT', 'NS', 'SRV']),
+                    name: z.string(),
+                    value: z.string(),
+                    ttl: z.number().default(3600),
+                    priority: z.number().optional(),
+                })
+                    .parse(args);
+                const result = await client.createDnsRecord(a.agentId, {
+                    type: a.type,
+                    name: a.name,
+                    value: a.value,
+                    ttl: a.ttl,
+                    priority: a.priority,
+                });
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'update_dns_record': {
+                const a = z
+                    .object({
+                    agentId: z.string(),
+                    recordId: z.string(),
+                    type: z.enum(['A', 'AAAA', 'ALIAS', 'CNAME', 'MX', 'TXT', 'NS', 'SRV']).optional(),
+                    name: z.string().optional(),
+                    value: z.string().optional(),
+                    ttl: z.number().optional(),
+                    priority: z.number().optional(),
+                })
+                    .parse(args);
+                const { agentId, recordId, ...record } = a;
+                const result = await client.updateDnsRecord(agentId, recordId, record);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'delete_dns_record': {
+                const a = z.object({ agentId: z.string(), recordId: z.string() }).parse(args);
+                const result = await client.deleteDnsRecord(a.agentId, a.recordId);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'reconfigure_ssl': {
+                const a = z.object({ agentId: z.string() }).parse(args);
+                const result = await client.reconfigureSsl(a.agentId);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'fund_renewal_vault': {
+                const a = z.object({ agentId: z.string(), amountUsdc: z.string() }).parse(args);
+                const result = await client.fundRenewalVault(a.agentId, a.amountUsdc);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'withdraw_renewal_vault': {
+                const a = z.object({ agentId: z.string(), amountUsdc: z.string() }).parse(args);
+                const result = await client.withdrawFromVault(a.agentId, a.amountUsdc);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'get_renewal_status': {
+                const a = z.object({ agentId: z.string() }).parse(args);
+                const result = await client.getRenewalStatus(a.agentId);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'get_service_plan': {
+                const a = z.object({ agentId: z.string() }).parse(args);
+                const result = await client.getServicePlan(a.agentId);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'purchase_service_plan': {
+                if (!AGENT_PRIVATE_KEY) {
+                    return {
+                        isError: true,
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'AGENT_PRIVATE_KEY env var is required to purchase a service plan.',
+                            },
+                        ],
+                    };
+                }
+                const a = z
+                    .object({
+                    agentId: z.string(),
+                    plan: z.enum(['pro', 'enterprise']),
+                    interval: z.enum(['monthly', 'yearly']),
+                    autoRenew: z.boolean().default(false),
+                    prepayPeriods: z.number().int().min(1).max(12).default(1),
+                })
+                    .parse(args);
+                const result = await client.purchaseServicePlan(a);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'enable_auto_renew': {
+                if (!AGENT_PRIVATE_KEY) {
+                    return {
+                        isError: true,
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'AGENT_PRIVATE_KEY env var is required to enable auto-renew. Use the owner wallet private key.',
+                            },
+                        ],
+                    };
+                }
+                if (!RENEWAL_VAULT_ADDRESS) {
+                    return {
+                        isError: true,
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'RENEWAL_VAULT_ADDRESS env var is required to enable auto-renew on-chain.',
+                            },
+                        ],
+                    };
+                }
+                const a = z.object({ agentId: z.string() }).parse(args);
+                const result = await client.setAutoRenew(a.agentId, true);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            default:
+                return {
+                    isError: true,
+                    content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+                };
+        }
+    }
+    catch (e) {
+        return {
+            isError: true,
+            content: [{ type: 'text', text: `Error: ${e instanceof Error ? e.message : String(e)}` }],
+        };
+    }
+});
+// ----------------------------------------------------------------------
+// MAIN
+// ----------------------------------------------------------------------
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('AgentDomain MCP server running on stdio');
+}
+main().catch((e) => {
+    console.error('Fatal:', e);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@agentdomain/mcp-server",
+  "version": "0.1.0",
+  "description": "MCP server exposing AgentDomain registration and management tools to any LLM",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "agentdomain-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "package.json"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "pnpm run build",
+    "dev": "tsx watch src/index.ts",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "lint": "echo \"no lint\""
+  },
+  "dependencies": {
+    "@agentdomain/sdk": "workspace:^",
+    "@agentdomain/shared": "workspace:^",
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "viem": "^2.21.55",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.5",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2"
+  }
+}