@cyanheads/whois-mcp-server 0.1.5 → 0.2.0

package/dist/app.d.ts

@@ -18,15 +18,21 @@ export declare const appOptions: {
         domain: import("zod").ZodString;
     }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
         domain: import("zod").ZodString;
-        available: import("zod").ZodNullable<import("zod").ZodBoolean>;
+        registration_status: import("zod").ZodEnum<{
+            not_found: "not_found";
+            registered: "registered";
+            unknown: "unknown";
+        }>;
+        available: import("zod").ZodNullable<import("zod").ZodLiteral<false>>;
         rdap_coverage: import("zod").ZodBoolean;
         registrar: import("zod").ZodOptional<import("zod").ZodString>;
         expiry_date: import("zod").ZodOptional<import("zod").ZodString>;
     }, import("zod/v4/core").$strip>, readonly [{
-        readonly reason: "invalid_domain";
+        readonly reason: "non_registrable_domain";
         readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
-        readonly when: "Input is not a valid FQDN.";
-        readonly recovery: "Provide a valid fully-qualified domain name like \"example.com\" or \"sub.example.org\".";
+        readonly when: "An ICANN-recognized suffix identifies the query as a subdomain.";
+        readonly recovery: "Query the registrable parent named in the error instead; no eligibility is implied.";
+        readonly thrownBy: "service";
     }], undefined> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
         domain: import("zod").ZodString;
     }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
@@ -51,18 +57,25 @@ export declare const appOptions: {
         rdap_source_error: import("zod").ZodOptional<import("zod").ZodString>;
         dns_source_error: import("zod").ZodOptional<import("zod").ZodString>;
     }, import("zod/v4/core").$strip>, readonly [{
-        readonly reason: "invalid_domain";
-        readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
-        readonly when: "Input is not a valid FQDN.";
-        readonly recovery: "Provide a valid fully-qualified domain name like \"example.com\" or \"sub.example.org\".";
-    }, {
         readonly reason: "both_legs_failed";
         readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ServiceUnavailable;
         readonly when: "Both RDAP and DoH legs failed — no data could be retrieved.";
         readonly recovery: "Both RDAP and DNS services are unavailable. Retry in a few minutes or check network connectivity.";
     }], undefined> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+        include_registrar: import("zod").ZodDefault<import("zod").ZodBoolean>;
         domain: import("zod").ZodString;
     }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        registrar_detail: import("zod").ZodOptional<import("zod").ZodObject<{
+            status: import("zod").ZodEnum<{
+                failed: "failed";
+                found: "found";
+                no_referral: "no_referral";
+            }>;
+            source: import("zod").ZodOptional<import("zod").ZodString>;
+            registrant_org: import("zod").ZodOptional<import("zod").ZodString>;
+            registrant_redacted: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
+            source_error: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
         domain: import("zod").ZodString;
         rdap_coverage: import("zod").ZodBoolean;
         handle: import("zod").ZodOptional<import("zod").ZodString>;
@@ -74,15 +87,10 @@ export declare const appOptions: {
         rdap_last_updated: import("zod").ZodOptional<import("zod").ZodString>;
         status: import("zod").ZodArray<import("zod").ZodString>;
         nameservers: import("zod").ZodArray<import("zod").ZodString>;
-        dnssec_signed: import("zod").ZodBoolean;
+        dnssec_signed: import("zod").ZodNullable<import("zod").ZodBoolean>;
         registrant_org: import("zod").ZodOptional<import("zod").ZodString>;
-        registrant_redacted: import("zod").ZodBoolean;
+        registrant_redacted: import("zod").ZodNullable<import("zod").ZodBoolean>;
     }, import("zod/v4/core").$strip>, readonly [{
-        readonly reason: "invalid_domain";
-        readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
-        readonly when: "Input is not a valid FQDN.";
-        readonly recovery: "Provide a valid fully-qualified domain name like \"example.com\" or \"sub.example.org\".";
-    }, {
         readonly reason: "rdap_no_coverage";
         readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
         readonly when: "TLD has no RDAP server in the IANA bootstrap — cannot perform lookup.";
@@ -90,8 +98,8 @@ export declare const appOptions: {
     }, {
         readonly reason: "domain_not_found";
         readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
-        readonly when: "RDAP server returned 404 — domain is not registered.";
-        readonly recovery: "The domain is not registered. Use whois_check_availability to confirm availability for registration.";
+        readonly when: "RDAP server returned 404 — no domain record found.";
+        readonly recovery: "Use whois_check_availability for record status; a missing record does not establish registration eligibility.";
     }], undefined> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
         domain: import("zod").ZodString;
         types: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodEnum<{
@@ -128,11 +136,30 @@ export declare const appOptions: {
             cloudflare: "cloudflare";
             nextdns: "nextdns";
         }>;
+        query_sources: import("zod").ZodArray<import("zod").ZodObject<{
+            type: import("zod").ZodEnum<{
+                A: "A";
+                AAAA: "AAAA";
+                CAA: "CAA";
+                CNAME: "CNAME";
+                MX: "MX";
+                NS: "NS";
+                PTR: "PTR";
+                SOA: "SOA";
+                TXT: "TXT";
+            }>;
+            source: import("zod").ZodEnum<{
+                cloudflare: "cloudflare";
+                nextdns: "nextdns";
+            }>;
+        }, import("zod/v4/core").$strip>>;
     }, import("zod/v4/core").$strip>, readonly [{
-        readonly reason: "invalid_domain";
-        readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
-        readonly when: "Input is not a valid FQDN.";
-        readonly recovery: "Provide a valid fully-qualified domain name like \"example.com\" or \"sub.example.org\".";
+        readonly reason: "dns_response_failed";
+        readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ServiceUnavailable;
+        readonly when: "Resolvers return a DNS failure status or truncated response after retry and fallback.";
+        readonly recovery: "Retry the DNS query later or choose another record type.";
+        readonly thrownBy: "service";
+        readonly retryable: true;
     }], undefined> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
         ip: import("zod").ZodString;
     }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
@@ -141,6 +168,7 @@ export declare const appOptions: {
         start_address: import("zod").ZodOptional<import("zod").ZodString>;
         end_address: import("zod").ZodOptional<import("zod").ZodString>;
         cidr: import("zod").ZodOptional<import("zod").ZodString>;
+        cidrs: import("zod").ZodArray<import("zod").ZodString>;
         ip_version: import("zod").ZodOptional<import("zod").ZodString>;
         name: import("zod").ZodOptional<import("zod").ZodString>;
         type: import("zod").ZodOptional<import("zod").ZodString>;
@@ -148,8 +176,21 @@ export declare const appOptions: {
         org_name: import("zod").ZodOptional<import("zod").ZodString>;
         abuse_email: import("zod").ZodOptional<import("zod").ZodString>;
         ptr: import("zod").ZodNullable<import("zod").ZodString>;
+        ptr_status: import("zod").ZodEnum<{
+            failed: "failed";
+            found: "found";
+            not_found: "not_found";
+        }>;
+        ptr_source_error: import("zod").ZodOptional<import("zod").ZodString>;
         rdap_source: import("zod").ZodOptional<import("zod").ZodString>;
     }, import("zod/v4/core").$strip>, readonly [{
+        readonly reason: "ip_no_rdap_route";
+        readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+        readonly when: "A successfully loaded IANA bootstrap has no covering RIR route.";
+        readonly recovery: "Try another address; this range has no RDAP route in the IANA bootstrap.";
+        readonly retryable: false;
+        readonly thrownBy: "service";
+    }, {
         readonly reason: "invalid_ip";
         readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
         readonly when: "Input is not a valid IPv4, IPv6, or CIDR address.";
@@ -157,8 +198,8 @@ export declare const appOptions: {
     }, {
         readonly reason: "private_range";
         readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
-        readonly when: "Input is a private or reserved range — no RIR RDAP record exists for it.";
-        readonly recovery: "Use a public, globally-routable IP address. RFC 1918, loopback, and link-local addresses have no RIR records.";
+        readonly when: "The numeric address falls within the server’s explicit excluded ranges.";
+        readonly recovery: "Choose an address outside the excluded ranges listed in this tool’s description.";
         readonly thrownBy: "service";
     }, {
         readonly reason: "ip_not_found";
@@ -181,8 +222,8 @@ export declare const appOptions: {
     }, import("zod/v4/core").$strip>, readonly [{
         readonly reason: "invalid_asn";
         readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
-        readonly when: "Input does not match AS<number> or bare integer format.";
-        readonly recovery: "Provide a valid ASN like \"AS15169\" or \"15169\". Numbers must be positive integers.";
+        readonly when: "The complete token is not a decimal ASN from 1 to 4294967295.";
+        readonly recovery: "Provide a decimal integer from 1 to 4294967295, optionally prefixed with AS and +, such as \"AS15169\" or \"+15169\".";
         readonly thrownBy: "service";
     }, {
         readonly reason: "asn_not_found";

package/dist/app.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../src/app.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAYH,eAAO,MAAM,UAAU;;;IAGrB;;;;;;OAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwBuB,CAAC"}
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../src/app.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAaH,eAAO,MAAM,UAAU;;;IAGrB;;;;;;OAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBuB,CAAC"}

package/dist/app.js

@@ -3,6 +3,7 @@
  * the entry point starts and tests assert against.
  * @module app
  */
+import { getServerConfig } from './config/server-config.js';
 import { whoisCheckAvailability } from './mcp-server/tools/definitions/whois-check-availability.tool.js';
 import { whoisGetDns } from './mcp-server/tools/definitions/whois-get-dns.tool.js';
 import { whoisGetDossier } from './mcp-server/tools/definitions/whois-get-dossier.tool.js';
@@ -33,13 +34,14 @@ export const appOptions = {
     resources: [],
     prompts: [],
     instructions: 'whois-mcp-server: domain and IP intelligence via RDAP and DNS-over-HTTPS. No API keys required.\n' +
-        '- whois_lookup_domain: full registration record (registrar, dates, status, nameservers)\n' +
-        '- whois_check_availability: is a domain available to register? (RDAP 404 = available)\n' +
-        '- whois_get_dns: DNS records for any hostname (A, AAAA, MX, TXT, NS, CNAME, SOA, CAA, PTR)\n' +
-        '- whois_lookup_ip: IP/CIDR netblock, org, abuse contact, and PTR via RIR RDAP\n' +
+        '- whois_lookup_domain: registry record; include_registrar opts into separate registrar contact detail\n' +
+        '- whois_check_availability: registered/not_found/unknown RDAP record status; absence does not establish registration eligibility\n' +
+        '- whois_get_dns: ASCII DNS owner names, including underscores and one root dot (A, AAAA, MX, TXT, NS, CNAME, SOA, CAA, PTR)\n' +
+        '- whois_lookup_ip: IP/CIDR netblock CIDRs, org, abuse contact, and found/not_found/failed PTR outcome\n' +
         '- whois_lookup_asn: ASN to org/RIR resolution\n' +
-        '- whois_get_dossier: one-call domain triage — registration + DNS in parallel with inferred signals',
+        '- whois_get_dossier: domain triage with partial source errors; absent DNSSEC/privacy evidence stays unknown',
     setup(core) {
+        getServerConfig();
         initRdapService(core.config, core.storage);
         initDohService(core.config, core.storage);
     },

package/dist/app.js.map

@@ -1 +1 @@
-{"version":3,"file":"app.js","sourceRoot":"","sources":["../src/app.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,sBAAsB,EAAE,MAAM,iEAAiE,CAAC;AACzG,OAAO,EAAE,WAAW,EAAE,MAAM,sDAAsD,CAAC;AACnF,OAAO,EAAE,eAAe,EAAE,MAAM,0DAA0D,CAAC;AAC3F,OAAO,EAAE,cAAc,EAAE,MAAM,yDAAyD,CAAC;AACzF,OAAO,EAAE,iBAAiB,EAAE,MAAM,4DAA4D,CAAC;AAC/F,OAAO,EAAE,aAAa,EAAE,MAAM,wDAAwD,CAAC;AACvF,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAElE,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,IAAI,EAAE,kBAAkB;IACxB,KAAK,EAAE,kBAAkB;IACzB;;;;;;OAMG;IACH,WAAW,EAAE,WAAW;IACxB,KAAK,EAAE;QACL,iBAAiB;QACjB,sBAAsB;QACtB,WAAW;QACX,aAAa;QACb,cAAc;QACd,eAAe;KAChB;IACD,SAAS,EAAE,EAAE;IACb,OAAO,EAAE,EAAE;IACX,YAAY,EACV,mGAAmG;QACnG,2FAA2F;QAC3F,yFAAyF;QACzF,8FAA8F;QAC9F,iFAAiF;QACjF,iDAAiD;QACjD,oGAAoG;IACtG,KAAK,CAAC,IAAI;QACR,eAAe,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QAC3C,cAAc,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IAC5C,CAAC;CACyB,CAAC"}
+{"version":3,"file":"app.js","sourceRoot":"","sources":["../src/app.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,sBAAsB,EAAE,MAAM,iEAAiE,CAAC;AACzG,OAAO,EAAE,WAAW,EAAE,MAAM,sDAAsD,CAAC;AACnF,OAAO,EAAE,eAAe,EAAE,MAAM,0DAA0D,CAAC;AAC3F,OAAO,EAAE,cAAc,EAAE,MAAM,yDAAyD,CAAC;AACzF,OAAO,EAAE,iBAAiB,EAAE,MAAM,4DAA4D,CAAC;AAC/F,OAAO,EAAE,aAAa,EAAE,MAAM,wDAAwD,CAAC;AACvF,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAElE,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,IAAI,EAAE,kBAAkB;IACxB,KAAK,EAAE,kBAAkB;IACzB;;;;;;OAMG;IACH,WAAW,EAAE,WAAW;IACxB,KAAK,EAAE;QACL,iBAAiB;QACjB,sBAAsB;QACtB,WAAW;QACX,aAAa;QACb,cAAc;QACd,eAAe;KAChB;IACD,SAAS,EAAE,EAAE;IACb,OAAO,EAAE,EAAE;IACX,YAAY,EACV,mGAAmG;QACnG,yGAAyG;QACzG,oIAAoI;QACpI,+HAA+H;QAC/H,yGAAyG;QACzG,iDAAiD;QACjD,6GAA6G;IAC/G,KAAK,CAAC,IAAI;QACR,eAAe,EAAE,CAAC;QAClB,eAAe,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QAC3C,cAAc,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IAC5C,CAAC;CACyB,CAAC"}

package/dist/mcp-server/tools/definitions/_fqdn.d.ts

@@ -1,7 +1,13 @@
 /**
- * @fileoverview Shared FQDN validation used across tool handlers.
+ * @fileoverview Serializable identifier grammars shared by lookup schemas.
  * @module mcp-server/tools/definitions/_fqdn
  */
-/** Simple FQDN validation: labels separated by dots, no consecutive dots, length limits */
-export declare function isValidFqdn(domain: string): boolean;
+/** Registration hostname grammar, with exact end-of-input matching. */
+export declare const REGISTRATION_NAME_PATTERN: RegExp;
+/** DNS presentation-name grammar: underscore labels and one optional root dot. */
+export declare const DNS_NAME_PATTERN: RegExp;
+/** Conservative IP/CIDR shape; complete address and prefix validity are semantic. */
+export declare const IP_PATTERN: RegExp;
+/** Accepted ASN spelling, preserving padding, case and surrounding whitespace. */
+export declare const ASN_PATTERN: RegExp;
 //# sourceMappingURL=_fqdn.d.ts.map

package/dist/mcp-server/tools/definitions/_fqdn.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"_fqdn.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/_fqdn.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,2FAA2F;AAC3F,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAQnD"}
+{"version":3,"file":"_fqdn.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/_fqdn.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,uEAAuE;AACvE,eAAO,MAAM,yBAAyB,QAErC,CAAC;AACF,kFAAkF;AAClF,eAAO,MAAM,gBAAgB,QACwE,CAAC;AACtG,qFAAqF;AACrF,eAAO,MAAM,UAAU,QAA2C,CAAC;AACnE,kFAAkF;AAClF,eAAO,MAAM,WAAW,QAA+C,CAAC"}

package/dist/mcp-server/tools/definitions/_fqdn.js

@@ -1,18 +1,14 @@
 /**
- * @fileoverview Shared FQDN validation used across tool handlers.
+ * @fileoverview Serializable identifier grammars shared by lookup schemas.
  * @module mcp-server/tools/definitions/_fqdn
  */
-/** Simple FQDN validation: labels separated by dots, no consecutive dots, length limits */
-export function isValidFqdn(domain) {
-    if (!domain || domain.length > 253)
-        return false;
-    const labels = domain.split('.');
-    if (labels.length < 2)
-        return false;
-    return labels.every((label) => {
-        if (!label || label.length > 63)
-            return false;
-        return /^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$|^[a-zA-Z0-9]$/.test(label);
-    });
-}
+const HOST_LABEL = '[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?';
+/** Registration hostname grammar, with exact end-of-input matching. */
+export const REGISTRATION_NAME_PATTERN = new RegExp(`^${HOST_LABEL}(?:\\.${HOST_LABEL})+(?![\\s\\S])`);
+/** DNS presentation-name grammar: underscore labels and one optional root dot. */
+export const DNS_NAME_PATTERN = /^(?=[A-Za-z0-9_.-]{1,253}\.?(?![\s\S]))[A-Za-z0-9_-]{1,63}(?:\.[A-Za-z0-9_-]{1,63})+\.?(?![\s\S])/;
+/** Conservative IP/CIDR shape; complete address and prefix validity are semantic. */
+export const IP_PATTERN = /^[0-9A-Fa-f:.]+(?:\/[0-9]+)?(?![\s\S])/;
+/** Accepted ASN spelling, preserving padding, case and surrounding whitespace. */
+export const ASN_PATTERN = /^\s*(?:[Aa][Ss]\s*)?\+?[0-9]+\s*(?![\s\S])/;
 //# sourceMappingURL=_fqdn.js.map

package/dist/mcp-server/tools/definitions/_fqdn.js.map

@@ -1 +1 @@
-{"version":3,"file":"_fqdn.js","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/_fqdn.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,2FAA2F;AAC3F,MAAM,UAAU,WAAW,CAAC,MAAc;IACxC,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,GAAG,GAAG;QAAE,OAAO,KAAK,CAAC;IACjD,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACjC,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,KAAK,CAAC;IACpC,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;QAC5B,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,MAAM,GAAG,EAAE;YAAE,OAAO,KAAK,CAAC;QAC9C,OAAO,wDAAwD,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC9E,CAAC,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"_fqdn.js","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/_fqdn.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,UAAU,GAAG,+CAA+C,CAAC;AACnE,uEAAuE;AACvE,MAAM,CAAC,MAAM,yBAAyB,GAAG,IAAI,MAAM,CACjD,IAAI,UAAU,SAAS,UAAU,gBAAgB,CAClD,CAAC;AACF,kFAAkF;AAClF,MAAM,CAAC,MAAM,gBAAgB,GAC3B,mGAAmG,CAAC;AACtG,qFAAqF;AACrF,MAAM,CAAC,MAAM,UAAU,GAAG,wCAAwC,CAAC;AACnE,kFAAkF;AAClF,MAAM,CAAC,MAAM,WAAW,GAAG,4CAA4C,CAAC"}

package/dist/mcp-server/tools/definitions/whois-check-availability.tool.d.ts

@@ -1,5 +1,5 @@
 /**
- * @fileoverview whois_check_availability tool — domain availability check via RDAP 404 semantics.
+ * @fileoverview whois_check_availability tool — registry record status without an eligibility guarantee.
  * @module mcp-server/tools/definitions/whois-check-availability.tool
  */
 import { z } from '@cyanheads/mcp-ts-core';
@@ -8,14 +8,20 @@ export declare const whoisCheckAvailability: import("@cyanheads/mcp-ts-core").To
     domain: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
     domain: z.ZodString;
-    available: z.ZodNullable<z.ZodBoolean>;
+    registration_status: z.ZodEnum<{
+        not_found: "not_found";
+        registered: "registered";
+        unknown: "unknown";
+    }>;
+    available: z.ZodNullable<z.ZodLiteral<false>>;
     rdap_coverage: z.ZodBoolean;
     registrar: z.ZodOptional<z.ZodString>;
     expiry_date: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, readonly [{
-    readonly reason: "invalid_domain";
+    readonly reason: "non_registrable_domain";
     readonly code: JsonRpcErrorCode.ValidationError;
-    readonly when: "Input is not a valid FQDN.";
-    readonly recovery: "Provide a valid fully-qualified domain name like \"example.com\" or \"sub.example.org\".";
+    readonly when: "An ICANN-recognized suffix identifies the query as a subdomain.";
+    readonly recovery: "Query the registrable parent named in the error instead; no eligibility is implied.";
+    readonly thrownBy: "service";
 }], undefined>;
 //# sourceMappingURL=whois-check-availability.tool.d.ts.map

package/dist/mcp-server/tools/definitions/whois-check-availability.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"whois-check-availability.tool.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/whois-check-availability.tool.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAQ,CAAC,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAIjE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;cAoGjC,CAAC"}
+{"version":3,"file":"whois-check-availability.tool.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/whois-check-availability.tool.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAQ,CAAC,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAIjE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;cA4FjC,CAAC"}

package/dist/mcp-server/tools/definitions/whois-check-availability.tool.js

@@ -1,70 +1,64 @@
 /**
- * @fileoverview whois_check_availability tool — domain availability check via RDAP 404 semantics.
+ * @fileoverview whois_check_availability tool — registry record status without an eligibility guarantee.
  * @module mcp-server/tools/definitions/whois-check-availability.tool
  */
 import { tool, z } from '@cyanheads/mcp-ts-core';
 import { JsonRpcErrorCode } from '@cyanheads/mcp-ts-core/errors';
 import { getRdapService } from '../../../services/rdap/rdap-service.js';
-import { isValidFqdn } from './_fqdn.js';
+import { REGISTRATION_NAME_PATTERN } from './_fqdn.js';
 export const whoisCheckAvailability = tool('whois_check_availability', {
-    title: 'Domain Availability Check',
-    description: 'Check whether a domain name is registered or available for registration. Returns available: true when ' +
-        'the domain is not registered, available: false with registrar and expiry_date when it is registered, and ' +
-        'available: null with rdap_coverage: false when the TLD has no RDAP coverage. ' +
-        'Designed for "can I register X" and bulk name sweeps. For the full registration record use whois_lookup_domain.',
+    title: 'Domain Registration Status',
+    description: 'Check RDAP registry record status: registered, not_found, or unknown when coverage is absent. ' +
+        'available is false for a found record and null otherwise; a registry miss never guarantees registration eligibility. ' +
+        'Known ICANN subdomains are rejected with their registrable parent; private suffixes are not registration boundaries. ' +
+        'For the full record use whois_lookup_domain.',
     annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
     input: z.object({
         domain: z
             .string()
+            .max(253)
+            .regex(REGISTRATION_NAME_PATTERN, 'Provide a dot-separated ASCII hostname such as example.com; labels are 1–63 characters, without underscores, whitespace or a root dot.')
             .describe('Fully qualified domain name to check (e.g., "myfuturename.com"). ' +
             'Must be a valid FQDN — labels separated by dots.'),
     }),
     output: z.object({
         domain: z.string().describe('Normalized domain name checked.'),
+        registration_status: z
+            .enum(['registered', 'not_found', 'unknown'])
+            .describe('Registry record present, absent, or RDAP coverage unavailable; never registration eligibility.'),
         available: z
-            .boolean()
+            .literal(false)
             .nullable()
-            .describe('True = available for registration. False = registered. ' +
-            'Null = rdap_coverage is false — cannot determine availability for this TLD.'),
+            .describe('False when a registration record exists; otherwise null. A registry miss never establishes availability.'),
         rdap_coverage: z.boolean().describe('True when a RDAP server was found for this TLD.'),
         registrar: z.string().optional().describe('Registrar name when available: false.'),
         expiry_date: z.string().optional().describe('Expiry date when available: false.'),
     }),
     errors: [
         {
-            reason: 'invalid_domain',
+            reason: 'non_registrable_domain',
             code: JsonRpcErrorCode.ValidationError,
-            when: 'Input is not a valid FQDN.',
-            recovery: 'Provide a valid fully-qualified domain name like "example.com" or "sub.example.org".',
+            when: 'An ICANN-recognized suffix identifies the query as a subdomain.',
+            recovery: 'Query the registrable parent named in the error instead; no eligibility is implied.',
+            thrownBy: 'service',
         },
     ],
     async handler(input, ctx) {
-        if (!isValidFqdn(input.domain)) {
-            throw ctx.fail('invalid_domain', `"${input.domain}" is not a valid FQDN.`, {
-                ...ctx.recoveryFor('invalid_domain'),
-            });
-        }
         ctx.log.info('RDAP availability check', { domain: input.domain });
         const result = await getRdapService().checkAvailability(input.domain, ctx);
-        if (result.available === null) {
-            // No RDAP coverage — surface as data, not an error
+        if (result.registration_status !== 'registered') {
             return {
                 domain: input.domain.toLowerCase(),
                 available: null,
-                rdap_coverage: false,
-            };
-        }
-        if (result.available === true) {
-            return {
-                domain: input.domain.toLowerCase(),
-                available: true,
-                rdap_coverage: true,
+                registration_status: result.registration_status,
+                rdap_coverage: result.rdap_coverage,
             };
         }
         // Registered
         return {
             domain: result.record.domain,
             available: false,
+            registration_status: result.registration_status,
             rdap_coverage: true,
             registrar: result.record.registrar,
             expiry_date: result.record.expiry_date,
@@ -73,18 +67,9 @@ export const whoisCheckAvailability = tool('whois_check_availability', {
     format: (result) => {
         const lines = [];
         lines.push(`# Domain: ${result.domain}`);
-        if (result.available === null) {
-            lines.push(`**Available:** Unknown (no RDAP coverage for this TLD)`);
-            lines.push(`**RDAP Coverage:** No`);
-        }
-        else if (result.available === true) {
-            lines.push(`**Available:** Yes — not currently registered`);
-            lines.push(`**RDAP Coverage:** Yes`);
-        }
-        else {
-            lines.push(`**Available:** No — registered`);
-            lines.push(`**RDAP Coverage:** Yes`);
-        }
+        lines.push(`**Registration Status:** ${result.registration_status}`);
+        lines.push(`**Available:** ${result.available === false ? 'No — registered' : 'Unknown — RDAP record absence does not establish eligibility'}`);
+        lines.push(`**RDAP Coverage:** ${result.rdap_coverage ? 'Yes' : 'No'}`);
         if (result.registrar)
             lines.push(`**Registrar:** ${result.registrar}`);
         if (result.expiry_date)

package/dist/mcp-server/tools/definitions/whois-check-availability.tool.js.map

@@ -1 +1 @@
-{"version":3,"file":"whois-check-availability.tool.js","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/whois-check-availability.tool.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"whois-check-availability.tool.js","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/whois-check-availability.tool.ts"],"names":[],"mappings":"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"}

package/dist/mcp-server/tools/definitions/whois-get-dns.tool.d.ts

@@ -40,10 +40,29 @@ export declare const whoisGetDns: import("@cyanheads/mcp-ts-core").ToolDefinitio
         cloudflare: "cloudflare";
         nextdns: "nextdns";
     }>;
+    query_sources: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            A: "A";
+            AAAA: "AAAA";
+            CAA: "CAA";
+            CNAME: "CNAME";
+            MX: "MX";
+            NS: "NS";
+            PTR: "PTR";
+            SOA: "SOA";
+            TXT: "TXT";
+        }>;
+        source: z.ZodEnum<{
+            cloudflare: "cloudflare";
+            nextdns: "nextdns";
+        }>;
+    }, z.core.$strip>>;
 }, z.core.$strip>, readonly [{
-    readonly reason: "invalid_domain";
-    readonly code: JsonRpcErrorCode.ValidationError;
-    readonly when: "Input is not a valid FQDN.";
-    readonly recovery: "Provide a valid fully-qualified domain name like \"example.com\" or \"sub.example.org\".";
+    readonly reason: "dns_response_failed";
+    readonly code: JsonRpcErrorCode.ServiceUnavailable;
+    readonly when: "Resolvers return a DNS failure status or truncated response after retry and fallback.";
+    readonly recovery: "Retry the DNS query later or choose another record type.";
+    readonly thrownBy: "service";
+    readonly retryable: true;
 }], undefined>;
 //# sourceMappingURL=whois-get-dns.tool.d.ts.map

package/dist/mcp-server/tools/definitions/whois-get-dns.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"whois-get-dns.tool.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/whois-get-dns.tool.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAQ,CAAC,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAOjE,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8GtB,CAAC"}
+{"version":3,"file":"whois-get-dns.tool.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/whois-get-dns.tool.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAQ,CAAC,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAMjE,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmItB,CAAC"}