@agentdomain/agentkit-plugin 0.1.0

package/README.md

@@ -0,0 +1,19 @@
+# @agentdomain/agentkit-plugin
+
+Coinbase AgentKit action provider for AgentDomain.
+
+```bash
+npm install @agentdomain/agentkit-plugin
+```
+
+The provider exposes actions for:
+
+- Agent identity registration and quote
+- Registry search
+- Email send/list
+- DNS list/create/update/delete
+- SSL reconfiguration
+- RenewalVault status, funding, auto-renew, and withdrawal
+- Per-agent Pro and Enterprise service plans
+
+Default API base: `https://agentdomain.app/api/v1`.

package/dist/index.d.ts

@@ -0,0 +1,162 @@
+import { z } from 'zod';
+declare const QuoteSchema: z.ZodObject<{
+    preferredName: z.ZodString;
+    tld: z.ZodDefault<z.ZodEnum<["xyz", "com", "ai", "org", "io", "net", "co", "app"]>>;
+    registerBasename: z.ZodDefault<z.ZodBoolean>;
+    basenameLabel: z.ZodOptional<z.ZodString>;
+    registerEns: z.ZodDefault<z.ZodBoolean>;
+    ensLabel: z.ZodOptional<z.ZodString>;
+    emailEnabled: z.ZodDefault<z.ZodBoolean>;
+    years: z.ZodDefault<z.ZodNumber>;
+    discountCode: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    preferredName: string;
+    tld: "xyz" | "com" | "ai" | "org" | "io" | "net" | "co" | "app";
+    registerBasename: boolean;
+    registerEns: boolean;
+    emailEnabled: boolean;
+    years: number;
+    basenameLabel?: string | undefined;
+    ensLabel?: string | undefined;
+    discountCode?: string | undefined;
+}, {
+    preferredName: string;
+    tld?: "xyz" | "com" | "ai" | "org" | "io" | "net" | "co" | "app" | undefined;
+    registerBasename?: boolean | undefined;
+    basenameLabel?: string | undefined;
+    registerEns?: boolean | undefined;
+    ensLabel?: string | undefined;
+    emailEnabled?: boolean | undefined;
+    years?: number | undefined;
+    discountCode?: string | undefined;
+}>;
+declare const SearchSchema: z.ZodObject<{
+    q: z.ZodOptional<z.ZodString>;
+    framework: z.ZodOptional<z.ZodEnum<["agentkit", "eliza", "crewai", "langchain", "openai", "anthropic"]>>;
+    capability: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    q?: string | undefined;
+    framework?: "agentkit" | "eliza" | "crewai" | "langchain" | "openai" | "anthropic" | undefined;
+    capability?: string | undefined;
+}, {
+    q?: string | undefined;
+    framework?: "agentkit" | "eliza" | "crewai" | "langchain" | "openai" | "anthropic" | undefined;
+    capability?: string | undefined;
+    limit?: number | undefined;
+}>;
+declare const RenewalStatusSchema: z.ZodObject<{
+    agentId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    agentId: string;
+}, {
+    agentId: string;
+}>;
+interface WalletProvider {
+    getAddress(): string;
+    signTypedData?: (data: unknown) => Promise<string>;
+    signMessage?: (message: string) => Promise<string>;
+    sendTransaction?: (tx: unknown) => Promise<string>;
+}
+export interface AgentDomainActionProviderOptions {
+    apiUrl?: string;
+    apiKey?: string;
+    baseRpcUrl?: string;
+    renewalVaultAddress?: string;
+    network?: 'base' | 'base-sepolia';
+}
+export declare class AgentDomainActionProvider {
+    readonly name = "agentdomain";
+    private readonly apiUrl;
+    private readonly apiKey?;
+    private readonly baseRpcUrl;
+    private readonly renewalVaultAddress?;
+    private readonly network;
+    constructor(opts?: AgentDomainActionProviderOptions);
+    private createAgentDomain;
+    getActions(): ({
+        name: string;
+        description: string;
+        schema: z.ZodObject<{
+            preferredName: z.ZodString;
+            tld: z.ZodDefault<z.ZodEnum<["xyz", "com", "ai", "org", "io", "net", "co", "app"]>>;
+            registerBasename: z.ZodDefault<z.ZodBoolean>;
+            basenameLabel: z.ZodOptional<z.ZodString>;
+            registerEns: z.ZodDefault<z.ZodBoolean>;
+            ensLabel: z.ZodOptional<z.ZodString>;
+            emailEnabled: z.ZodDefault<z.ZodBoolean>;
+            years: z.ZodDefault<z.ZodNumber>;
+            discountCode: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            preferredName: string;
+            tld: "xyz" | "com" | "ai" | "org" | "io" | "net" | "co" | "app";
+            registerBasename: boolean;
+            registerEns: boolean;
+            emailEnabled: boolean;
+            years: number;
+            basenameLabel?: string | undefined;
+            ensLabel?: string | undefined;
+            discountCode?: string | undefined;
+        }, {
+            preferredName: string;
+            tld?: "xyz" | "com" | "ai" | "org" | "io" | "net" | "co" | "app" | undefined;
+            registerBasename?: boolean | undefined;
+            basenameLabel?: string | undefined;
+            registerEns?: boolean | undefined;
+            ensLabel?: string | undefined;
+            emailEnabled?: boolean | undefined;
+            years?: number | undefined;
+            discountCode?: string | undefined;
+        }>;
+        invoke: (walletProvider: WalletProvider, args: z.infer<typeof QuoteSchema>) => Promise<string>;
+    } | {
+        name: string;
+        description: string;
+        schema: z.ZodObject<{
+            q: z.ZodOptional<z.ZodString>;
+            framework: z.ZodOptional<z.ZodEnum<["agentkit", "eliza", "crewai", "langchain", "openai", "anthropic"]>>;
+            capability: z.ZodOptional<z.ZodString>;
+            limit: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            limit: number;
+            q?: string | undefined;
+            framework?: "agentkit" | "eliza" | "crewai" | "langchain" | "openai" | "anthropic" | undefined;
+            capability?: string | undefined;
+        }, {
+            q?: string | undefined;
+            framework?: "agentkit" | "eliza" | "crewai" | "langchain" | "openai" | "anthropic" | undefined;
+            capability?: string | undefined;
+            limit?: number | undefined;
+        }>;
+        invoke: (walletProvider: WalletProvider, args: z.infer<typeof SearchSchema>) => Promise<string>;
+    } | {
+        name: string;
+        description: string;
+        schema: z.ZodObject<{
+            agentId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            agentId: string;
+        }, {
+            agentId: string;
+        }>;
+        invoke: (walletProvider: WalletProvider, args: z.infer<typeof RenewalStatusSchema>) => Promise<string>;
+    })[];
+    private register;
+    private renewalStatus;
+    private fundRenewal;
+    private enableAutoRenew;
+    private reconfigureSsl;
+    private listDns;
+    private createDns;
+    private updateDns;
+    private deleteDns;
+    private withdrawRenewal;
+    private getServicePlan;
+    private purchaseServicePlan;
+    private quote;
+    private search;
+    private sendEmail;
+    private listEmail;
+}
+export default AgentDomainActionProvider;

package/dist/index.js

@@ -0,0 +1,404 @@
+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, encodeFunctionData, } from 'viem';
+import { base, baseSepolia } from 'viem/chains';
+const RegisterSchema = z.object({
+    preferredName: z.string().min(3).max(63),
+    tld: z.enum(SUPPORTED_TLDS).default('xyz'),
+    registerBasename: z.boolean().default(true),
+    basenameLabel: z.string().min(3).max(63).optional(),
+    registerEns: z.boolean().default(false),
+    ensLabel: z.string().min(3).max(63).optional(),
+    ownerAddress: z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/)
+        .optional(),
+    emailEnabled: z.boolean().default(false),
+    dnsTarget: z.string().url().optional(),
+    years: z.number().int().min(1).max(10).default(1),
+    autoRenew: z.boolean().default(false),
+    discountCode: z.string().max(50).optional(),
+});
+const QuoteSchema = z.object({
+    preferredName: z.string(),
+    tld: z.enum(SUPPORTED_TLDS).default('xyz'),
+    registerBasename: z.boolean().default(true),
+    basenameLabel: z.string().min(3).max(63).optional(),
+    registerEns: z.boolean().default(false),
+    ensLabel: z.string().min(3).max(63).optional(),
+    emailEnabled: z.boolean().default(false),
+    years: z.number().int().min(1).max(10).default(1),
+    discountCode: z.string().max(50).optional(),
+});
+const SearchSchema = z.object({
+    q: z.string().optional(),
+    framework: z.enum(SUPPORTED_FRAMEWORKS).optional(),
+    capability: z.string().optional(),
+    limit: z.number().default(20),
+});
+const SendEmailSchema = z.object({
+    agentId: z.string(),
+    to: z.union([z.string().email(), z.array(z.string().email()).min(1).max(10)]),
+    subject: z.string().min(1).max(200),
+    text: z.string().min(1).max(20_000),
+});
+const ListEmailSchema = z.object({
+    agentId: z.string(),
+    limit: z.number().int().min(1).max(100).default(20),
+});
+const RenewalStatusSchema = z.object({
+    agentId: z.string().min(1),
+});
+const FundRenewalSchema = z.object({
+    agentId: z.string().min(1),
+    amountUsdc: z.string().regex(/^\d+(\.\d{1,6})?$/, 'Use a USDC amount with up to 6 decimals'),
+    enableAutoRenew: z.boolean().default(false),
+});
+const EnableAutoRenewSchema = z.object({
+    agentId: z.string().min(1),
+});
+const SslReconfigureSchema = z.object({
+    agentId: z.string().min(1),
+});
+const DnsRecordTypeSchema = z.enum(['A', 'AAAA', 'ALIAS', 'CNAME', 'MX', 'TXT', 'NS', 'SRV']);
+const ListDnsSchema = z.object({
+    agentId: z.string().min(1),
+});
+const CreateDnsSchema = z.object({
+    agentId: z.string().min(1),
+    type: DnsRecordTypeSchema,
+    name: z.string().min(1).max(253),
+    value: z.string().min(1).max(4096),
+    ttl: z.number().int().min(60).max(3600).default(3600),
+    priority: z.number().int().min(0).optional(),
+});
+const UpdateDnsSchema = CreateDnsSchema.partial().extend({
+    agentId: z.string().min(1),
+    recordId: z.string().min(1),
+});
+const DeleteDnsSchema = z.object({
+    agentId: z.string().min(1),
+    recordId: z.string().min(1),
+});
+const WithdrawRenewalSchema = z.object({
+    agentId: z.string().min(1),
+    amountUsdc: z.string().regex(/^\d+(\.\d{1,6})?$/, 'Use a USDC amount with up to 6 decimals'),
+});
+const ServicePlanStatusSchema = z.object({
+    agentId: z.string().min(1),
+});
+const PurchaseServicePlanSchema = z.object({
+    agentId: z.string().min(1),
+    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),
+});
+export class AgentDomainActionProvider {
+    name = 'agentdomain';
+    apiUrl;
+    apiKey;
+    baseRpcUrl;
+    renewalVaultAddress;
+    network;
+    constructor(opts = {}) {
+        this.apiUrl = opts.apiUrl ?? AGENTDOMAIN_API_BASE_URL;
+        this.apiKey = opts.apiKey;
+        this.baseRpcUrl = opts.baseRpcUrl ?? 'https://mainnet.base.org';
+        this.renewalVaultAddress = opts.renewalVaultAddress;
+        this.network = opts.network ?? 'base';
+    }
+    createAgentDomain(walletProvider) {
+        const wallet = walletProvider.getAddress();
+        const chain = this.network === 'base-sepolia' ? baseSepolia : base;
+        const publicClient = createPublicClient({ chain, transport: http(this.baseRpcUrl) });
+        const walletClient = createWalletClient({
+            chain,
+            transport: http(this.baseRpcUrl),
+            account: {
+                address: wallet,
+                signTypedData: walletProvider.signTypedData,
+                signMessage: walletProvider.signMessage
+                    ? (parameters) => walletProvider.signMessage(parameters.message)
+                    : undefined,
+            },
+        });
+        const ad = new AgentDomain({
+            apiUrl: this.apiUrl,
+            apiKey: this.apiKey,
+            network: this.network,
+            renewalVaultAddress: this.renewalVaultAddress,
+            walletClient: walletClient,
+            publicClient: publicClient,
+        });
+        return { ad, wallet, walletClient, publicClient, chain };
+    }
+    getActions() {
+        return [
+            {
+                name: 'register_agent_identity',
+                description: 'Register a complete agent identity bundle on AgentDomain. Domain, DNS, SSL certification, and service fee are mandatory. Set registerBasename/registerEns/emailEnabled false to skip those optional costs. Pays in USDC on Base.',
+                schema: RegisterSchema,
+                invoke: this.register.bind(this),
+            },
+            {
+                name: 'quote_agent_registration',
+                description: 'Price an agent identity registration before committing. Quote includes mandatory SSL certification fee; optional Basename, ENS, and email only charge when enabled.',
+                schema: QuoteSchema,
+                invoke: this.quote.bind(this),
+            },
+            {
+                name: 'search_agents',
+                description: 'Search the public AgentDomain registry.',
+                schema: SearchSchema,
+                invoke: this.search.bind(this),
+            },
+            {
+                name: 'send_agent_email',
+                description: 'Send text-only email from an email-enabled agent via AWS SES.',
+                schema: SendEmailSchema,
+                invoke: this.sendEmail.bind(this),
+            },
+            {
+                name: 'list_agent_email',
+                description: 'Query text-only agent email and extracted verification codes.',
+                schema: ListEmailSchema,
+                invoke: this.listEmail.bind(this),
+            },
+            {
+                name: 'get_renewal_status',
+                description: 'Get exact next renewal amount, shortfall, vault balance, expiry date, and auto-renew state for an AgentDomain identity.',
+                schema: RenewalStatusSchema,
+                invoke: this.renewalStatus.bind(this),
+            },
+            {
+                name: 'fund_renewal_vault',
+                description: 'Deposit USDC from the connected wallet into one AgentID renewal vault. Anyone can fund; only the AgentID owner can withdraw or enable auto-renew. Call get_renewal_status first and usually deposit the returned shortfall.',
+                schema: FundRenewalSchema,
+                invoke: this.fundRenewal.bind(this),
+            },
+            {
+                name: 'enable_auto_renew',
+                description: 'Enable RenewalVault auto-renew. Requires the wallet provider to be the AgentID NFT owner and support sendTransaction.',
+                schema: EnableAutoRenewSchema,
+                invoke: this.enableAutoRenew.bind(this),
+            },
+            {
+                name: 'reconfigure_ssl',
+                description: 'Rebuild the Cloudflare SaaS SSL hostname and sync the required Spaceship DNS validation records for an existing agent.',
+                schema: SslReconfigureSchema,
+                invoke: this.reconfigureSsl.bind(this),
+            },
+            {
+                name: 'list_dns_records',
+                description: 'List DNS records for an AgentDomain identity.',
+                schema: ListDnsSchema,
+                invoke: this.listDns.bind(this),
+            },
+            {
+                name: 'create_dns_record',
+                description: 'Create a user-managed DNS record and sync it to the domain provider.',
+                schema: CreateDnsSchema,
+                invoke: this.createDns.bind(this),
+            },
+            {
+                name: 'update_dns_record',
+                description: 'Update a user-managed DNS record and sync it to the domain provider.',
+                schema: UpdateDnsSchema,
+                invoke: this.updateDns.bind(this),
+            },
+            {
+                name: 'delete_dns_record',
+                description: 'Delete a user-managed DNS record and sync the domain provider state.',
+                schema: DeleteDnsSchema,
+                invoke: this.deleteDns.bind(this),
+            },
+            {
+                name: 'withdraw_renewal_vault',
+                description: 'Withdraw unused USDC from an AgentID renewal vault. Requires the AgentID NFT owner wallet.',
+                schema: WithdrawRenewalSchema,
+                invoke: this.withdrawRenewal.bind(this),
+            },
+            {
+                name: 'get_service_plan',
+                description: 'Get the current per-agent service plan, limits, and billing state.',
+                schema: ServicePlanStatusSchema,
+                invoke: this.getServicePlan.bind(this),
+            },
+            {
+                name: 'purchase_service_plan',
+                description: 'Upgrade one agent to AgentDomain Pro or Enterprise using x402 USDC payment.',
+                schema: PurchaseServicePlanSchema,
+                invoke: this.purchaseServicePlan.bind(this),
+            },
+        ];
+    }
+    async register(walletProvider, args) {
+        const { ad, wallet } = this.createAgentDomain(walletProvider);
+        const result = await ad.register({ ...args, wallet });
+        let autoRenewMsg = '';
+        if (args.autoRenew && this.renewalVaultAddress) {
+            try {
+                if (walletProvider.sendTransaction) {
+                    const data = encodeFunctionData({
+                        abi: [
+                            {
+                                type: 'function',
+                                name: 'setAutoRenew',
+                                inputs: [
+                                    { name: 'tokenId', type: 'uint256' },
+                                    { name: 'enabled', type: 'bool' },
+                                ],
+                            },
+                        ],
+                        functionName: 'setAutoRenew',
+                        args: [BigInt(result.nftTokenId), true],
+                    });
+                    const txHash = await walletProvider.sendTransaction({
+                        to: this.renewalVaultAddress,
+                        data,
+                    });
+                    autoRenewMsg = ` Auto-renew enabled via tx ${txHash}.`;
+                }
+                else {
+                    autoRenewMsg =
+                        ' (Cannot enable auto-renew because walletProvider lacks sendTransaction).';
+                }
+            }
+            catch (e) {
+                autoRenewMsg = ` Failed to enable auto-renew: ${String(e)}`;
+            }
+        }
+        return `Registered identity ${result.domain} (token #${result.nftTokenId}).${autoRenewMsg}`;
+    }
+    async renewalStatus(walletProvider, args) {
+        const { ad } = this.createAgentDomain(walletProvider);
+        const status = await ad.getRenewalStatus(args.agentId);
+        return `Renewal status for ${status.domain}: next renewal $${status.nextRenewalAmountUsdc}, vault balance $${status.vaultBalanceUsdc}, shortfall $${status.shortfallUsdc}, expires ${status.expiresAt ?? 'unknown'}, renewable from ${status.renewableFrom ?? 'unknown'}, auto-renew ${status.autoRenewEnabled ? 'enabled' : 'off'}.`;
+    }
+    async fundRenewal(walletProvider, args) {
+        const { ad } = this.createAgentDomain(walletProvider);
+        const result = await ad.fundRenewalVault(args.agentId, args.amountUsdc);
+        let message = `Deposited $${args.amountUsdc} USDC into the renewal vault for ${result.domain}. Vault balance is now ${result.vaultBalance} atomic USDC.`;
+        if (args.enableAutoRenew) {
+            message += ` ${await this.enableAutoRenew(walletProvider, { agentId: args.agentId })}`;
+        }
+        return message;
+    }
+    async enableAutoRenew(walletProvider, args) {
+        if (!this.renewalVaultAddress) {
+            throw new Error('renewalVaultAddress is required to enable auto-renew.');
+        }
+        if (!walletProvider.sendTransaction) {
+            throw new Error('walletProvider.sendTransaction is required to enable auto-renew.');
+        }
+        const { ad, wallet } = this.createAgentDomain(walletProvider);
+        const status = await ad.getRenewalStatus(args.agentId);
+        if (!status.tokenId)
+            throw new Error('AgentID NFT is not minted yet.');
+        if (status.ownerAddress && status.ownerAddress.toLowerCase() !== wallet.toLowerCase()) {
+            throw new Error(`Only the AgentID NFT owner (${status.ownerAddress}) can enable auto-renew.`);
+        }
+        const data = encodeFunctionData({
+            abi: [
+                {
+                    type: 'function',
+                    name: 'setAutoRenew',
+                    inputs: [
+                        { name: 'tokenId', type: 'uint256' },
+                        { name: 'enabled', type: 'bool' },
+                    ],
+                },
+            ],
+            functionName: 'setAutoRenew',
+            args: [BigInt(status.tokenId), true],
+        });
+        const txHash = await walletProvider.sendTransaction({
+            to: this.renewalVaultAddress,
+            data,
+        });
+        return `Auto-renew enabled via tx ${txHash}.`;
+    }
+    async reconfigureSsl(walletProvider, args) {
+        const { ad } = this.createAgentDomain(walletProvider);
+        const result = await ad.reconfigureSsl(args.agentId);
+        return `SSL reconfigured for ${result.domain}. Cloudflare hostname ${result.cloudflareCustomHostnameId} is ${result.sslStatus} and ${result.validationRecordsCount} validation record(s) were synced.`;
+    }
+    async listDns(walletProvider, args) {
+        const { ad } = this.createAgentDomain(walletProvider);
+        const records = await ad.listDnsRecords(args.agentId);
+        return JSON.stringify(records, null, 2);
+    }
+    async createDns(walletProvider, args) {
+        const { ad } = this.createAgentDomain(walletProvider);
+        const { agentId, ...record } = args;
+        const result = await ad.createDnsRecord(agentId, record);
+        return `Created ${result.type} record ${result.name} -> ${result.value}.`;
+    }
+    async updateDns(walletProvider, args) {
+        const { ad } = this.createAgentDomain(walletProvider);
+        const { agentId, recordId, ...record } = args;
+        const result = await ad.updateDnsRecord(agentId, recordId, record);
+        return `Updated ${result.type} record ${result.name} -> ${result.value}.`;
+    }
+    async deleteDns(walletProvider, args) {
+        const { ad } = this.createAgentDomain(walletProvider);
+        await ad.deleteDnsRecord(args.agentId, args.recordId);
+        return `Deleted DNS record ${args.recordId}.`;
+    }
+    async withdrawRenewal(walletProvider, args) {
+        if (!walletProvider.sendTransaction) {
+            throw new Error('walletProvider.sendTransaction is required to withdraw vault funds.');
+        }
+        const { ad } = this.createAgentDomain(walletProvider);
+        const tx = await ad.withdrawFromVault(args.agentId, args.amountUsdc);
+        const txHash = await walletProvider.sendTransaction({
+            to: tx.to,
+            data: tx.data,
+            value: tx.value,
+            chainId: tx.chainId,
+        });
+        return `Submitted renewal vault withdrawal for $${args.amountUsdc} USDC via tx ${txHash}.`;
+    }
+    async getServicePlan(walletProvider, args) {
+        const { ad } = this.createAgentDomain(walletProvider);
+        const result = await ad.getServicePlan(args.agentId);
+        return `Service plan for ${result.domain}: ${result.entitlement.plan} (${result.entitlement.status}), email ${result.entitlement.limits.emailPerHour}/hour and ${result.entitlement.limits.emailPerDay}/day, ${result.entitlement.limits.apiKeys} API key(s), ${result.entitlement.limits.dnsRecords} DNS records.`;
+    }
+    async purchaseServicePlan(walletProvider, args) {
+        const { ad } = this.createAgentDomain(walletProvider);
+        const result = await ad.purchaseServicePlan(args);
+        return `Purchased ${result.entitlement.plan} ${args.interval} for ${result.domain}. Current period ends ${result.entitlement.currentPeriodEnd ?? 'unknown'}.`;
+    }
+    async quote(walletProvider, args) {
+        const { ad } = this.createAgentDomain(walletProvider);
+        const q = await ad.quote(args);
+        const emailPart = Number(q.emailFeeUsdc) > 0 ? ` + email $${q.emailFeeUsdc}` : '';
+        const basenamePart = Number(q.basenameCostUsdc) > 0 ? ` + Basename $${q.basenameCostUsdc}` : '';
+        const ensPart = Number(q.ensCostUsdc) > 0 ? ` + ENS $${q.ensCostUsdc}` : '';
+        return `Total: $${q.totalUsdc} USDC (domain $${q.domainCostUsdc} + SSL $${q.sslCertificationFeeUsdc} + service $${q.serviceFeeUsdc}${emailPart}${basenamePart}${ensPart})`;
+    }
+    async search(walletProvider, args) {
+        const { ad } = this.createAgentDomain(walletProvider);
+        const result = await ad.search(args);
+        return `Found ${result.total} agents. First ${result.items.length}: ${result.items
+            .map((a) => a.domain)
+            .join(', ')}`;
+    }
+    async sendEmail(walletProvider, args) {
+        const { ad } = this.createAgentDomain(walletProvider);
+        const result = await ad.sendEmail(args.agentId, {
+            to: args.to,
+            subject: args.subject,
+            text: args.text,
+        });
+        return `Email sent via SES: ${result.id}`;
+    }
+    async listEmail(walletProvider, args) {
+        const { ad } = this.createAgentDomain(walletProvider);
+        const result = await ad.listEmail(args.agentId, { limit: args.limit });
+        return JSON.stringify(result, null, 2);
+    }
+}
+export default AgentDomainActionProvider;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@agentdomain/agentkit-plugin",
+  "version": "0.1.0",
+  "description": "Coinbase AgentKit action provider for AgentDomain",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "package.json"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "pnpm run build",
+    "typecheck": "tsc --noEmit",
+    "lint": "echo \"no lint\""
+  },
+  "dependencies": {
+    "@agentdomain/sdk": "workspace:^",
+    "@agentdomain/shared": "workspace:^",
+    "viem": "^2.21.55",
+    "zod": "^3.24.1"
+  },
+  "peerDependencies": {
+    "@coinbase/agentkit": "^0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.2"
+  }
+}