@agentdomain/agentkit-plugin 0.5.1 → 0.7.0

package/NOTICE

@@ -0,0 +1,5 @@
+AgentDomain public developer tools and verified Base contracts
+Copyright 2026 Md. Rakib
+
+AgentDomain and related names and logos are trademarks or service marks of
+their respective owner. This license does not grant trademark rights.

package/README.md

@@ -10,10 +10,27 @@ The provider exposes actions for:
 
 - Agent identity registration and quote
 - Registry search
-- Email send/list/delete/batch, monthly usage, signed inbound webhooks, primary address updates, and Starter/Pro/Enterprise aliases
-- DNS list/create/update/delete
+- Email send/list/batch, monthly usage, signed inbound webhooks, primary address updates, and Starter/Pro/Enterprise aliases
+- Typed DNS list/create/update/delete for all 13 Spaceship-supported types, plus capabilities, batch preview/apply, and BIND import/export
 - SSL reconfiguration
 - RenewalVault status, funding, auto-renew, and withdrawal
-- Per-agent Starter, Pro, and exact Enterprise-tier Premium Plan purchase and renewal selection
+- Per-agent Starter, Pro, and Enterprise Premium Plans
 
 Default API base: `https://agentdomain.app/api/v1`.
+
+Request the base URL directly to retrieve AgentDomain's machine-readable API discovery metadata.
+
+Provide your public ERC-8021 app identifier when constructing the action
+provider:
+
+```ts
+const provider = new AgentDomainActionProvider({
+  builderCode: process.env.AGENTDOMAIN_BUILDER_CODE,
+  renewalVaultAddress: process.env.RENEWAL_VAULT_ADDRESS,
+});
+```
+
+`builderCode` is required only for direct Base writes such as auto-renew and
+vault withdrawal. Missing or invalid attribution stops those actions before
+`walletProvider.sendTransaction`; reads, signatures, and x402 v2 paid requests
+keep their existing behavior.

package/dist/index.d.ts

@@ -56,6 +56,47 @@ declare const EmailUsageSchema: z.ZodObject<{
 }, {
     agentId: string;
 }>;
+declare const CreateDnsSchema: z.ZodEffects<z.ZodObject<{
+    agentId: z.ZodString;
+    type: z.ZodEnum<["A", "AAAA", "ALIAS", "CAA", "CNAME", "HTTPS", "MX", "NS", "PTR", "SRV", "SVCB", "TLSA", "TXT"]>;
+    name: z.ZodString;
+    value: z.ZodOptional<z.ZodString>;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    ttl: z.ZodDefault<z.ZodNumber>;
+    priority: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "A" | "AAAA" | "ALIAS" | "CAA" | "CNAME" | "HTTPS" | "MX" | "NS" | "PTR" | "SRV" | "SVCB" | "TLSA" | "TXT";
+    agentId: string;
+    name: string;
+    ttl: number;
+    value?: string | undefined;
+    data?: Record<string, unknown> | undefined;
+    priority?: number | undefined;
+}, {
+    type: "A" | "AAAA" | "ALIAS" | "CAA" | "CNAME" | "HTTPS" | "MX" | "NS" | "PTR" | "SRV" | "SVCB" | "TLSA" | "TXT";
+    agentId: string;
+    name: string;
+    value?: string | undefined;
+    data?: Record<string, unknown> | undefined;
+    ttl?: number | undefined;
+    priority?: number | undefined;
+}>, {
+    type: "A" | "AAAA" | "ALIAS" | "CAA" | "CNAME" | "HTTPS" | "MX" | "NS" | "PTR" | "SRV" | "SVCB" | "TLSA" | "TXT";
+    agentId: string;
+    name: string;
+    ttl: number;
+    value?: string | undefined;
+    data?: Record<string, unknown> | undefined;
+    priority?: number | undefined;
+}, {
+    type: "A" | "AAAA" | "ALIAS" | "CAA" | "CNAME" | "HTTPS" | "MX" | "NS" | "PTR" | "SRV" | "SVCB" | "TLSA" | "TXT";
+    agentId: string;
+    name: string;
+    value?: string | undefined;
+    data?: Record<string, unknown> | undefined;
+    ttl?: number | undefined;
+    priority?: number | undefined;
+}>;
 interface WalletProvider {
     getAddress(): string;
     signTypedData?: (data: unknown) => Promise<string>;
@@ -68,6 +109,8 @@ export interface AgentDomainActionProviderOptions {
     baseRpcUrl?: string;
     renewalVaultAddress?: string;
     network?: 'base' | 'base-sepolia';
+    /** Public ERC-8021 app code required for direct Base transaction actions. */
+    builderCode?: string;
 }
 export declare class AgentDomainActionProvider {
     readonly name = "agentdomain";
@@ -76,6 +119,7 @@ export declare class AgentDomainActionProvider {
     private readonly baseRpcUrl;
     private readonly renewalVaultAddress?;
     private readonly network;
+    private readonly builderCode?;
     constructor(opts?: AgentDomainActionProviderOptions);
     private createAgentDomain;
     getActions(): ({
@@ -147,16 +191,66 @@ export declare class AgentDomainActionProvider {
             agentId: string;
         }>;
         invoke: (walletProvider: WalletProvider, args: z.infer<typeof EmailUsageSchema>) => Promise<string>;
+    } | {
+        name: string;
+        description: string;
+        schema: z.ZodEffects<z.ZodObject<{
+            agentId: z.ZodString;
+            type: z.ZodEnum<["A", "AAAA", "ALIAS", "CAA", "CNAME", "HTTPS", "MX", "NS", "PTR", "SRV", "SVCB", "TLSA", "TXT"]>;
+            name: z.ZodString;
+            value: z.ZodOptional<z.ZodString>;
+            data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            ttl: z.ZodDefault<z.ZodNumber>;
+            priority: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            type: "A" | "AAAA" | "ALIAS" | "CAA" | "CNAME" | "HTTPS" | "MX" | "NS" | "PTR" | "SRV" | "SVCB" | "TLSA" | "TXT";
+            agentId: string;
+            name: string;
+            ttl: number;
+            value?: string | undefined;
+            data?: Record<string, unknown> | undefined;
+            priority?: number | undefined;
+        }, {
+            type: "A" | "AAAA" | "ALIAS" | "CAA" | "CNAME" | "HTTPS" | "MX" | "NS" | "PTR" | "SRV" | "SVCB" | "TLSA" | "TXT";
+            agentId: string;
+            name: string;
+            value?: string | undefined;
+            data?: Record<string, unknown> | undefined;
+            ttl?: number | undefined;
+            priority?: number | undefined;
+        }>, {
+            type: "A" | "AAAA" | "ALIAS" | "CAA" | "CNAME" | "HTTPS" | "MX" | "NS" | "PTR" | "SRV" | "SVCB" | "TLSA" | "TXT";
+            agentId: string;
+            name: string;
+            ttl: number;
+            value?: string | undefined;
+            data?: Record<string, unknown> | undefined;
+            priority?: number | undefined;
+        }, {
+            type: "A" | "AAAA" | "ALIAS" | "CAA" | "CNAME" | "HTTPS" | "MX" | "NS" | "PTR" | "SRV" | "SVCB" | "TLSA" | "TXT";
+            agentId: string;
+            name: string;
+            value?: string | undefined;
+            data?: Record<string, unknown> | undefined;
+            ttl?: number | undefined;
+            priority?: number | undefined;
+        }>;
+        invoke: (walletProvider: WalletProvider, args: z.infer<typeof CreateDnsSchema>) => Promise<string>;
     })[];
     private register;
     private renewalStatus;
     private fundRenewal;
     private enableAutoRenew;
+    private requireBuilderCode;
     private reconfigureSsl;
     private listDns;
+    private getDnsCapabilities;
     private createDns;
     private updateDns;
     private deleteDns;
+    private changeDns;
+    private importDns;
+    private exportDns;
     private withdrawRenewal;
     private getServicePlan;
     private purchaseServicePlan;

package/dist/index.js

@@ -1,7 +1,8 @@
 import { z } from 'zod';
-import { AgentDomain } from '@agentdomain/sdk';
+import { AgentDomain, encodeSetAutoRenewCalldata } from '@agentdomain/sdk';
+import { DNS_RECORD_TYPES, dnsRecordSchema } from '@agentdomain/shared';
 import { AGENTDOMAIN_API_BASE_URL, SERVICE_PLAN_KEYS, SUPPORTED_FRAMEWORKS, SUPPORTED_TLDS, } from '@agentdomain/shared/constants';
-import { createPublicClient, createWalletClient, http, encodeFunctionData, } from 'viem';
+import { createPublicClient, createWalletClient, http } from 'viem';
 import { base, baseSepolia } from 'viem/chains';
 const RegisterSchema = z.object({
     preferredName: z.string().min(3).max(63),
@@ -90,26 +91,56 @@ const EnableAutoRenewSchema = z.object({
 const SslReconfigureSchema = z.object({
     agentId: z.string().min(1),
 });
-const DnsRecordTypeSchema = z.enum(['A', 'AAAA', 'ALIAS', 'CNAME', 'MX', 'TXT', 'NS', 'SRV']);
+const DnsRecordTypeSchema = z.enum(DNS_RECORD_TYPES);
 const ListDnsSchema = z.object({
     agentId: z.string().min(1),
 });
-const CreateDnsSchema = z.object({
+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),
+    value: z.string().min(1).max(65_535).optional(),
+    data: z.record(z.unknown()).optional(),
     ttl: z.number().int().min(60).max(3600).default(3600),
-    priority: z.number().int().min(0).optional(),
+    priority: z.number().int().min(0).max(65_535).optional(),
+})
+    .refine((record) => record.value !== undefined || record.data !== undefined, {
+    message: 'Provide structured data or the legacy value field',
+    path: ['data'],
 });
-const UpdateDnsSchema = CreateDnsSchema.partial().extend({
+const UpdateDnsSchema = z.object({
     agentId: z.string().min(1),
     recordId: z.string().min(1),
+    type: DnsRecordTypeSchema.optional(),
+    name: z.string().min(1).max(253).optional(),
+    value: z.string().min(1).max(65_535).optional(),
+    data: z.record(z.unknown()).optional(),
+    ttl: z.number().int().min(60).max(3600).optional(),
+    priority: z.number().int().min(0).max(65_535).optional(),
 });
 const DeleteDnsSchema = z.object({
     agentId: z.string().min(1),
     recordId: z.string().min(1),
 });
+const ChangeDnsSchema = z.object({
+    agentId: z.string().min(1),
+    records: z.array(dnsRecordSchema).min(1).max(200),
+    mode: z.enum(['merge', 'replace']).default('merge'),
+    dryRun: z.boolean().default(true),
+    baseRevision: z.string().length(64).optional(),
+});
+const ImportDnsSchema = z.object({
+    agentId: z.string().min(1),
+    zoneFile: z.string().min(1).max(262_144),
+    mode: z.enum(['merge', 'replace']).default('merge'),
+    dryRun: z.boolean().default(true),
+    baseRevision: z.string().length(64).optional(),
+});
+const ExportDnsSchema = z.object({
+    agentId: z.string().min(1),
+    scope: z.enum(['user', 'all']).default('user'),
+});
 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'),
@@ -151,12 +182,14 @@ export class AgentDomainActionProvider {
     baseRpcUrl;
     renewalVaultAddress;
     network;
+    builderCode;
     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';
+        this.builderCode = opts.builderCode;
     }
     createAgentDomain(walletProvider) {
         const wallet = walletProvider.getAddress();
@@ -178,6 +211,7 @@ export class AgentDomainActionProvider {
             apiKey: this.apiKey,
             network: this.network,
             renewalVaultAddress: this.renewalVaultAddress,
+            builderCode: this.builderCode,
             walletClient: walletClient,
             publicClient: publicClient,
         });
@@ -263,6 +297,12 @@ export class AgentDomainActionProvider {
                 schema: SslReconfigureSchema,
                 invoke: this.reconfigureSsl.bind(this),
             },
+            {
+                name: 'get_dns_capabilities',
+                description: 'Get machine-readable DNS types, fields, limits, and provider constraints.',
+                schema: ListDnsSchema,
+                invoke: this.getDnsCapabilities.bind(this),
+            },
             {
                 name: 'list_dns_records',
                 description: 'List DNS records for an AgentDomain identity.',
@@ -287,6 +327,24 @@ export class AgentDomainActionProvider {
                 schema: DeleteDnsSchema,
                 invoke: this.deleteDns.bind(this),
             },
+            {
+                name: 'change_dns_records',
+                description: 'Preview or apply a revision-protected DNS batch in merge or replace mode.',
+                schema: ChangeDnsSchema,
+                invoke: this.changeDns.bind(this),
+            },
+            {
+                name: 'import_dns_zone',
+                description: 'Preview or apply a validated BIND zone import without deleting system-managed records.',
+                schema: ImportDnsSchema,
+                invoke: this.importDns.bind(this),
+            },
+            {
+                name: 'export_dns_zone',
+                description: 'Export user or permitted complete DNS state as a BIND zone file.',
+                schema: ExportDnsSchema,
+                invoke: this.exportDns.bind(this),
+            },
             {
                 name: 'withdraw_renewal_vault',
                 description: 'Withdraw unused USDC from an AgentID renewal vault. Requires the AgentID NFT owner wallet.',
@@ -338,30 +396,29 @@ export class AgentDomainActionProvider {
         ];
     }
     async register(walletProvider, args) {
-        const { ad, wallet } = this.createAgentDomain(walletProvider);
+        const { ad, wallet, publicClient } = this.createAgentDomain(walletProvider);
         const result = await ad.register({ ...args, emailEnabled: true, 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 data = encodeSetAutoRenewCalldata(BigInt(result.nftTokenId), true, this.requireBuilderCode('Registration auto-renew'));
                     const txHash = await walletProvider.sendTransaction({
                         to: this.renewalVaultAddress,
                         data,
                     });
+                    let receipt;
+                    try {
+                        receipt = await publicClient.waitForTransactionReceipt({
+                            hash: txHash,
+                        });
+                    }
+                    catch (e) {
+                        throw new Error(`Auto-renew transaction ${txHash} was submitted but confirmation failed or remained pending: ${String(e)}`);
+                    }
+                    if (receipt.status !== 'success') {
+                        throw new Error(`Auto-renew transaction ${txHash} confirmed with status ${receipt.status}; auto-renew was not enabled.`);
+                    }
                     autoRenewMsg = ` Auto-renew enabled via tx ${txHash}.`;
                 }
                 else {
@@ -403,25 +460,18 @@ export class AgentDomainActionProvider {
         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 data = encodeSetAutoRenewCalldata(BigInt(status.tokenId), true, this.requireBuilderCode('Auto-renew'));
         const txHash = await walletProvider.sendTransaction({
             to: this.renewalVaultAddress,
             data,
         });
-        return `Auto-renew enabled via tx ${txHash}.`;
+        return `Auto-renew transaction submitted via tx ${txHash}.`;
+    }
+    requireBuilderCode(operation) {
+        if (!this.builderCode) {
+            throw new Error(`${operation} requires builderCode in AgentDomainActionProvider options so the direct Base transaction is attributed.`);
+        }
+        return this.builderCode;
     }
     async reconfigureSsl(walletProvider, args) {
         const { ad } = this.createAgentDomain(walletProvider);
@@ -433,6 +483,10 @@ export class AgentDomainActionProvider {
         const records = await ad.listDnsRecords(args.agentId);
         return JSON.stringify(records, null, 2);
     }
+    async getDnsCapabilities(walletProvider, args) {
+        const { ad } = this.createAgentDomain(walletProvider);
+        return JSON.stringify(await ad.getDnsCapabilities(args.agentId), null, 2);
+    }
     async createDns(walletProvider, args) {
         const { ad } = this.createAgentDomain(walletProvider);
         const { agentId, ...record } = args;
@@ -450,6 +504,24 @@ export class AgentDomainActionProvider {
         await ad.deleteDnsRecord(args.agentId, args.recordId);
         return `Deleted DNS record ${args.recordId}.`;
     }
+    async changeDns(walletProvider, args) {
+        const { ad } = this.createAgentDomain(walletProvider);
+        const result = args.dryRun
+            ? await ad.previewDnsBatch(args.agentId, args.records, args.mode)
+            : await ad.applyDnsBatch(args.agentId, args.records, requireDnsRevision(args.baseRevision), args.mode);
+        return JSON.stringify(result, null, 2);
+    }
+    async importDns(walletProvider, args) {
+        const { ad } = this.createAgentDomain(walletProvider);
+        const result = args.dryRun
+            ? await ad.previewDnsImport(args.agentId, args.zoneFile, args.mode)
+            : await ad.applyDnsImport(args.agentId, args.zoneFile, requireDnsRevision(args.baseRevision), args.mode);
+        return JSON.stringify(result, null, 2);
+    }
+    async exportDns(walletProvider, args) {
+        const { ad } = this.createAgentDomain(walletProvider);
+        return ad.exportDnsZone(args.agentId, args.scope);
+    }
     async withdrawRenewal(walletProvider, args) {
         if (!walletProvider.sendTransaction) {
             throw new Error('walletProvider.sendTransaction is required to withdraw vault funds.');
@@ -552,4 +624,9 @@ export class AgentDomainActionProvider {
         return `Deleted email alias ${args.emailAddress}.`;
     }
 }
+function requireDnsRevision(value) {
+    if (!value)
+        throw new Error('Apply requires baseRevision from a fresh DNS dry-run preview.');
+    return value;
+}
 export default AgentDomainActionProvider;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentdomain/agentkit-plugin",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "description": "Coinbase AgentKit action provider for AgentDomain",
   "license": "Apache-2.0",
   "repository": "https://github.com/0xmdrakib/AgentDomain.git",
@@ -18,6 +18,8 @@
   "files": [
     "dist",
     "README.md",
+    "LICENSE",
+    "NOTICE",
     "package.json"
   ],
   "publishConfig": {
@@ -26,8 +28,8 @@
   "dependencies": {
     "viem": "^2.55.2",
     "zod": "^3.24.1",
-    "@agentdomain/sdk": "^0.5.1",
-    "@agentdomain/shared": "^0.5.1"
+    "@agentdomain/shared": "^0.7.0",
+    "@agentdomain/sdk": "^0.7.0"
   },
   "peerDependencies": {
     "@coinbase/agentkit": "^0.1.0"
@@ -37,6 +39,7 @@
   },
   "scripts": {
     "build": "tsc",
+    "test": "pnpm --filter @agentdomain/sdk build && pnpm run build && node --test test/*.test.mjs",
     "typecheck": "tsc --noEmit",
     "lint": "echo \"no lint\""
   }