@cyanheads/federal-regulations-mcp-server 0.1.0

package/dist/mcp-server/tools/definitions/get-document.tool.js.map

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

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

@@ -0,0 +1,356 @@
+/**
+ * @fileoverview Barrel of all tool definitions for federal-regulations-mcp-server.
+ * @module mcp-server/tools/definitions/index
+ */
+export declare const allToolDefinitions: (import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    mode: import("zod").ZodEnum<{
+        search: "search";
+        structure: "structure";
+    }>;
+    title: import("zod").ZodOptional<import("zod").ZodNumber>;
+    part: import("zod").ZodOptional<import("zod").ZodString>;
+    query: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"">, import("zod").ZodString]>>;
+    date: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"">, import("zod").ZodString]>>;
+    per_page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    mode: import("zod").ZodEnum<{
+        search: "search";
+        structure: "structure";
+    }>;
+    date: import("zod").ZodOptional<import("zod").ZodString>;
+    nodes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        type: import("zod").ZodString;
+        identifier: import("zod").ZodString;
+        label: import("zod").ZodString;
+        description: import("zod").ZodNullable<import("zod").ZodString>;
+        reserved: import("zod").ZodBoolean;
+        cfrCite: import("zod").ZodNullable<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>>>;
+    source: import("zod").ZodOptional<import("zod").ZodEnum<{
+        mirror: "mirror";
+        live: "live";
+    }>>;
+    results: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        title: import("zod").ZodNumber;
+        part: import("zod").ZodString;
+        section: import("zod").ZodNullable<import("zod").ZodString>;
+        heading: import("zod").ZodString;
+        hierarchyPath: import("zod").ZodString;
+        excerpt: import("zod").ZodString;
+        cfrCite: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>>;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "query_required";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.InvalidParams;
+    readonly when: "mode=\"search\" with no query phrase.";
+    readonly recovery: "Provide a query phrase for search mode, or switch to mode=\"structure\" to browse.";
+}, {
+    readonly reason: "title_not_found";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Structure mode with a title outside 1–50, or a part not found in the title.";
+    readonly recovery: "Omit title to list all titles, or pick a number in 1–50 and a part that exists.";
+}, {
+    readonly reason: "no_results";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Search mode returned zero matches.";
+    readonly recovery: "Broaden the phrase or drop the title filter and retry.";
+}, {
+    readonly reason: "upstream_unavailable";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ServiceUnavailable;
+    readonly when: "eCFR returned a 5xx, timed out, or served an HTML error page (live path).";
+    readonly recovery: "Retry after a brief wait; the eCFR API may be momentarily down.";
+}], {
+    readonly totalCount: import("zod").ZodOptional<import("zod").ZodNumber>;
+    readonly truncated: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    readonly shown: import("zod").ZodOptional<import("zod").ZodNumber>;
+    readonly notice: import("zod").ZodOptional<import("zod").ZodString>;
+}> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    docket_id: import("zod").ZodOptional<import("zod").ZodString>;
+    document_object_id: import("zod").ZodOptional<import("zod").ZodString>;
+    fr_document_number: import("zod").ZodOptional<import("zod").ZodString>;
+    comment_id: import("zod").ZodOptional<import("zod").ZodString>;
+    per_page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+    page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    mode: import("zod").ZodEnum<{
+        list: "list";
+        detail: "detail";
+    }>;
+    target: import("zod").ZodOptional<import("zod").ZodString>;
+    comments: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        commentId: import("zod").ZodString;
+        title: import("zod").ZodString;
+        documentType: import("zod").ZodString;
+        postedDate: import("zod").ZodString;
+        agencyId: import("zod").ZodNullable<import("zod").ZodString>;
+        objectId: import("zod").ZodString;
+        withdrawn: import("zod").ZodBoolean;
+    }, import("zod/v4/core").$strip>>>;
+    commentId: import("zod").ZodOptional<import("zod").ZodString>;
+    title: import("zod").ZodOptional<import("zod").ZodString>;
+    docketId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    commentOnDocumentId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    postedDate: import("zod").ZodOptional<import("zod").ZodString>;
+    receivedDate: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    submitterName: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    organization: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    bodyText: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    attachmentOnly: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    attachments: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        title: import("zod").ZodString;
+        formats: import("zod").ZodArray<import("zod").ZodObject<{
+            format: import("zod").ZodString;
+            fileUrl: import("zod").ZodString;
+            size: import("zod").ZodNullable<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>>;
+    withdrawn: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    restrictReason: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "auth_required";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Unauthorized;
+    readonly when: "REGULATIONS_GOV_API_KEY is not configured.";
+    readonly recovery: "Set the REGULATIONS_GOV_API_KEY env var (free key at https://api.data.gov/signup/). The Federal Register and eCFR tools work without it.";
+}, {
+    readonly reason: "target_required";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.InvalidParams;
+    readonly when: "None of docket_id / document_object_id / fr_document_number / comment_id was given.";
+    readonly recovery: "Provide one targeting parameter — a docket ID, a document object ID, an FR document number, or a comment ID.";
+}, {
+    readonly reason: "not_found";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "The target docket/document/comment has no comments or does not exist.";
+    readonly recovery: "Verify the ID; comments often attach to the docket's primary document — try docket_id to widen, or check the docket reached its comment period.";
+}, {
+    readonly reason: "rate_limited";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.RateLimited;
+    readonly when: "Regulations.gov returned 429.";
+    readonly retryable: true;
+    readonly recovery: "Wait and retry — the per-key hourly limit (1,000/hr) was hit.";
+}, {
+    readonly reason: "upstream_unavailable";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ServiceUnavailable;
+    readonly when: "Regulations.gov returned a 5xx or timed out.";
+    readonly recovery: "Retry after a brief wait.";
+}], {
+    readonly totalCount: import("zod").ZodOptional<import("zod").ZodNumber>;
+    readonly truncated: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    readonly shown: import("zod").ZodOptional<import("zod").ZodNumber>;
+    readonly notice: import("zod").ZodOptional<import("zod").ZodString>;
+}> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    title: import("zod").ZodNumber;
+    part: import("zod").ZodString;
+    section: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"">, import("zod").ZodString]>>;
+    date: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"">, import("zod").ZodString]>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    cfrCite: import("zod").ZodString;
+    title: import("zod").ZodNumber;
+    part: import("zod").ZodString;
+    section: import("zod").ZodNullable<import("zod").ZodString>;
+    heading: import("zod").ZodString;
+    hierarchyPath: import("zod").ZodString;
+    date: import("zod").ZodString;
+    source: import("zod").ZodEnum<{
+        mirror: "mirror";
+        live: "live";
+    }>;
+    bodyText: import("zod").ZodString;
+    sections: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        section: import("zod").ZodString;
+        heading: import("zod").ZodString;
+        bodyText: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>>;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "not_found";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "No such title/part/section at that date.";
+    readonly recovery: "Verify the cite with regulations_browse_cfr (structure mode); the part or section may not exist or may be reserved.";
+}, {
+    readonly reason: "date_out_of_range";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.InvalidParams;
+    readonly when: "The requested date precedes eCFR historical coverage.";
+    readonly recovery: "Use a date from ~2017 onward, or omit date for the current text.";
+}, {
+    readonly reason: "upstream_unavailable";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ServiceUnavailable;
+    readonly when: "eCFR returned a 5xx, timed out, or served an HTML error page (live path).";
+    readonly recovery: "Retry after a brief wait; the eCFR API may be momentarily unavailable.";
+}], undefined> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    docket_id: import("zod").ZodString;
+    document_types: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+        "Proposed Rule": "Proposed Rule";
+        Rule: "Rule";
+        Notice: "Notice";
+        "Supporting & Related Material": "Supporting & Related Material";
+        Other: "Other";
+    }>>>;
+    per_page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+    page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    docketId: import("zod").ZodString;
+    title: import("zod").ZodString;
+    docketType: import("zod").ZodNullable<import("zod").ZodString>;
+    agencyId: import("zod").ZodNullable<import("zod").ZodString>;
+    rin: import("zod").ZodNullable<import("zod").ZodString>;
+    abstract: import("zod").ZodNullable<import("zod").ZodString>;
+    modifyDate: import("zod").ZodNullable<import("zod").ZodString>;
+    objectId: import("zod").ZodNullable<import("zod").ZodString>;
+    documentCount: import("zod").ZodNumber;
+    documents: import("zod").ZodArray<import("zod").ZodObject<{
+        documentId: import("zod").ZodString;
+        objectId: import("zod").ZodString;
+        title: import("zod").ZodString;
+        documentType: import("zod").ZodString;
+        postedDate: import("zod").ZodString;
+        frDocNum: import("zod").ZodNullable<import("zod").ZodString>;
+        commentEndDate: import("zod").ZodNullable<import("zod").ZodString>;
+        withdrawn: import("zod").ZodBoolean;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "auth_required";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Unauthorized;
+    readonly when: "REGULATIONS_GOV_API_KEY is not configured.";
+    readonly recovery: "Set the REGULATIONS_GOV_API_KEY env var (free key at https://api.data.gov/signup/). The Federal Register and eCFR tools work without it.";
+}, {
+    readonly reason: "not_found";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "No docket exists with that ID.";
+    readonly recovery: "Verify the docket ID from a Federal Register document's docketId; format is like \"EPA-HQ-OAR-2025-0194\".";
+}, {
+    readonly reason: "rate_limited";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.RateLimited;
+    readonly when: "Regulations.gov returned 429 (1,000 requests/hour per key).";
+    readonly retryable: true;
+    readonly recovery: "Wait and retry — the per-key hourly limit was hit.";
+}, {
+    readonly reason: "upstream_unavailable";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ServiceUnavailable;
+    readonly when: "Regulations.gov returned a 5xx or timed out.";
+    readonly recovery: "Retry after a brief wait.";
+}], {
+    readonly truncated: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    readonly shown: import("zod").ZodOptional<import("zod").ZodNumber>;
+    readonly notice: import("zod").ZodOptional<import("zod").ZodString>;
+}> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    document_number: import("zod").ZodString;
+    include_full_text: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    documentNumber: import("zod").ZodString;
+    title: import("zod").ZodString;
+    type: import("zod").ZodString;
+    abstract: import("zod").ZodNullable<import("zod").ZodString>;
+    action: import("zod").ZodNullable<import("zod").ZodString>;
+    dates: import("zod").ZodNullable<import("zod").ZodString>;
+    publicationDate: import("zod").ZodString;
+    effectiveOn: import("zod").ZodNullable<import("zod").ZodString>;
+    commentsCloseOn: import("zod").ZodNullable<import("zod").ZodString>;
+    agencies: import("zod").ZodArray<import("zod").ZodString>;
+    regulationIdNumbers: import("zod").ZodArray<import("zod").ZodString>;
+    cfrReferences: import("zod").ZodArray<import("zod").ZodObject<{
+        title: import("zod").ZodNumber;
+        part: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
+    docketId: import("zod").ZodNullable<import("zod").ZodString>;
+    regulationsGovDocumentId: import("zod").ZodNullable<import("zod").ZodString>;
+    commentCount: import("zod").ZodNullable<import("zod").ZodNumber>;
+    supportingDocuments: import("zod").ZodArray<import("zod").ZodObject<{
+        title: import("zod").ZodString;
+        documentId: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
+    bodyHtmlUrl: import("zod").ZodString;
+    rawTextUrl: import("zod").ZodString;
+    htmlUrl: import("zod").ZodString;
+    fullText: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "not_found";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "No Federal Register document exists with that number.";
+    readonly recovery: "Verify the number via regulations_search_rules; FR numbers look like \"2025-14555\".";
+}, {
+    readonly reason: "upstream_unavailable";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ServiceUnavailable;
+    readonly when: "Federal Register returned a 5xx, timed out, or served an HTML error page.";
+    readonly recovery: "Retry after a brief wait; the Federal Register API may be momentarily down.";
+}], undefined> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    query: import("zod").ZodOptional<import("zod").ZodString>;
+    agencies: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    closing_before: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"">, import("zod").ZodString]>>;
+    per_page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+    page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    asOf: import("zod").ZodString;
+    keyed: import("zod").ZodBoolean;
+    results: import("zod").ZodArray<import("zod").ZodObject<{
+        documentNumber: import("zod").ZodString;
+        title: import("zod").ZodString;
+        type: import("zod").ZodString;
+        agencies: import("zod").ZodArray<import("zod").ZodString>;
+        publicationDate: import("zod").ZodString;
+        commentsCloseOn: import("zod").ZodString;
+        daysRemaining: import("zod").ZodNumber;
+        docketIds: import("zod").ZodArray<import("zod").ZodString>;
+        commentCount: import("zod").ZodNullable<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "no_results";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "No rules open for comment match the filters.";
+    readonly recovery: "Drop the agency or closing_before filter — fewer rules are open than you might expect at any moment.";
+}, {
+    readonly reason: "upstream_unavailable";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ServiceUnavailable;
+    readonly when: "Federal Register returned a 5xx, timed out, or served an HTML error page.";
+    readonly recovery: "Retry after a brief wait; the Federal Register API may be momentarily down.";
+}], {
+    readonly totalCount: import("zod").ZodNumber;
+    readonly truncated: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    readonly shown: import("zod").ZodOptional<import("zod").ZodNumber>;
+    readonly notice: import("zod").ZodOptional<import("zod").ZodString>;
+}> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    query: import("zod").ZodOptional<import("zod").ZodString>;
+    type: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+        PRORULE: "PRORULE";
+        RULE: "RULE";
+        NOTICE: "NOTICE";
+        PRESDOCU: "PRESDOCU";
+    }>>>;
+    agencies: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    published_after: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"">, import("zod").ZodString]>>;
+    published_before: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"">, import("zod").ZodString]>>;
+    per_page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+    page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    results: import("zod").ZodArray<import("zod").ZodObject<{
+        documentNumber: import("zod").ZodString;
+        title: import("zod").ZodString;
+        type: import("zod").ZodString;
+        abstract: import("zod").ZodNullable<import("zod").ZodString>;
+        publicationDate: import("zod").ZodString;
+        agencies: import("zod").ZodArray<import("zod").ZodString>;
+        docketIds: import("zod").ZodArray<import("zod").ZodString>;
+        regulationIdNumbers: import("zod").ZodArray<import("zod").ZodString>;
+        cfrReferences: import("zod").ZodArray<import("zod").ZodObject<{
+            title: import("zod").ZodNumber;
+            part: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+        commentsCloseOn: import("zod").ZodNullable<import("zod").ZodString>;
+        effectiveOn: import("zod").ZodNullable<import("zod").ZodString>;
+        htmlUrl: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "no_results";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Zero matches for the query and filters.";
+    readonly recovery: "Broaden the query, widen the date range, or drop an agency filter and retry.";
+}, {
+    readonly reason: "upstream_unavailable";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ServiceUnavailable;
+    readonly when: "Federal Register returned a 5xx, timed out, or served an HTML error page.";
+    readonly recovery: "Retry after a brief wait; the Federal Register API may be momentarily down.";
+}], {
+    readonly totalCount: import("zod").ZodNumber;
+    readonly truncated: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    readonly shown: import("zod").ZodOptional<import("zod").ZodNumber>;
+    readonly notice: import("zod").ZodOptional<import("zod").ZodString>;
+}>)[];
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAUH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAQ9B,CAAC"}

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

@@ -0,0 +1,21 @@
+/**
+ * @fileoverview Barrel of all tool definitions for federal-regulations-mcp-server.
+ * @module mcp-server/tools/definitions/index
+ */
+import { browseCfrTool } from './browse-cfr.tool.js';
+import { findCommentsTool } from './find-comments.tool.js';
+import { getCfrSectionTool } from './get-cfr-section.tool.js';
+import { getDocketTool } from './get-docket.tool.js';
+import { getDocumentTool } from './get-document.tool.js';
+import { listOpenCommentsTool } from './list-open-comments.tool.js';
+import { searchRulesTool } from './search-rules.tool.js';
+export const allToolDefinitions = [
+    searchRulesTool,
+    getDocumentTool,
+    browseCfrTool,
+    getCfrSectionTool,
+    getDocketTool,
+    findCommentsTool,
+    listOpenCommentsTool,
+];
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,eAAe;IACf,eAAe;IACf,aAAa;IACb,iBAAiB;IACjB,aAAa;IACb,gBAAgB;IAChB,oBAAoB;CACrB,CAAC"}

package/dist/mcp-server/tools/definitions/list-open-comments.tool.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @fileoverview regulations_list_open_comments — rules currently open for public
+ * comment, filterable by agency and topic. "What can I still weigh in on?" Runs on
+ * the Federal Register's open-comment window (keyless); the comment count is read
+ * from each FR document's own embedded Regulations.gov info when a key is present.
+ * Degrades gracefully — fully functional without the key.
+ * @module mcp-server/tools/definitions/list-open-comments.tool
+ */
+import { z } from '@cyanheads/mcp-ts-core';
+import { JsonRpcErrorCode } from '@cyanheads/mcp-ts-core/errors';
+export declare const listOpenCommentsTool: import("@cyanheads/mcp-ts-core").ToolDefinition<z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    agencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    closing_before: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodString]>>;
+    per_page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>, z.ZodObject<{
+    asOf: z.ZodString;
+    keyed: z.ZodBoolean;
+    results: z.ZodArray<z.ZodObject<{
+        documentNumber: z.ZodString;
+        title: z.ZodString;
+        type: z.ZodString;
+        agencies: z.ZodArray<z.ZodString>;
+        publicationDate: z.ZodString;
+        commentsCloseOn: z.ZodString;
+        daysRemaining: z.ZodNumber;
+        docketIds: z.ZodArray<z.ZodString>;
+        commentCount: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, readonly [{
+    readonly reason: "no_results";
+    readonly code: JsonRpcErrorCode.NotFound;
+    readonly when: "No rules open for comment match the filters.";
+    readonly recovery: "Drop the agency or closing_before filter — fewer rules are open than you might expect at any moment.";
+}, {
+    readonly reason: "upstream_unavailable";
+    readonly code: JsonRpcErrorCode.ServiceUnavailable;
+    readonly when: "Federal Register returned a 5xx, timed out, or served an HTML error page.";
+    readonly recovery: "Retry after a brief wait; the Federal Register API may be momentarily down.";
+}], {
+    readonly totalCount: z.ZodNumber;
+    readonly truncated: z.ZodOptional<z.ZodBoolean>;
+    readonly shown: z.ZodOptional<z.ZodNumber>;
+    readonly notice: z.ZodOptional<z.ZodString>;
+}>;
+//# sourceMappingURL=list-open-comments.tool.d.ts.map

package/dist/mcp-server/tools/definitions/list-open-comments.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-open-comments.tool.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/list-open-comments.tool.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAQ,CAAC,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAgBjE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2L/B,CAAC"}

package/dist/mcp-server/tools/definitions/list-open-comments.tool.js

@@ -0,0 +1,179 @@
+/**
+ * @fileoverview regulations_list_open_comments — rules currently open for public
+ * comment, filterable by agency and topic. "What can I still weigh in on?" Runs on
+ * the Federal Register's open-comment window (keyless); the comment count is read
+ * from each FR document's own embedded Regulations.gov info when a key is present.
+ * Degrades gracefully — fully functional without the key.
+ * @module mcp-server/tools/definitions/list-open-comments.tool
+ */
+import { tool, z } from '@cyanheads/mcp-ts-core';
+import { JsonRpcErrorCode } from '@cyanheads/mcp-ts-core/errors';
+import { today } from '../../../services/ecfr/ecfr-service.js';
+import { getFederalRegisterService } from '../../../services/federal-register/federal-register-service.js';
+import { getRegulationsGovService } from '../../../services/regulations-gov/regulations-gov-service.js';
+import { escapePipes } from './format-utils.js';
+const FR_NAV_CEILING = 5000;
+/** Whole days from `asOf` (YYYY-MM-DD) to `close` (YYYY-MM-DD); negative clamped to 0. */
+function daysBetween(asOf, close) {
+    const a = Date.parse(`${asOf}T00:00:00Z`);
+    const c = Date.parse(`${close}T00:00:00Z`);
+    if (Number.isNaN(a) || Number.isNaN(c))
+        return 0;
+    return Math.max(0, Math.round((c - a) / 86_400_000));
+}
+export const listOpenCommentsTool = tool('regulations_list_open_comments', {
+    title: 'regulations_list_open_comments',
+    description: 'List rules currently open for public comment, filterable by agency slug and topic, sorted by closing date (soonest first). "What can I still weigh in on?" Runs on the Federal Register\'s open-comment window and is fully functional without a key. When REGULATIONS_GOV_API_KEY is configured, each row is enriched with the comment count from the Federal Register document\'s embedded Regulations.gov info (no extra rate-limited call). Open one row with regulations_get_document for the full proposal, or pull the comments with regulations_find_comments.',
+    annotations: { readOnlyHint: true, openWorldHint: true },
+    input: z.object({
+        query: z
+            .string()
+            .optional()
+            .describe('Full-text filter across open rules. Omit to list all rules currently open for comment.'),
+        agencies: z
+            .array(z.string())
+            .optional()
+            .describe('Filter to one or more agencies by Federal Register agency slug (e.g. "environmental-protection-agency").'),
+        closing_before: z
+            .union([
+            z.literal(''),
+            z
+                .string()
+                .regex(/^\d{4}-\d{2}-\d{2}$/)
+                .describe('ISO 8601 date (YYYY-MM-DD).'),
+        ])
+            .optional()
+            .describe('Only rules whose comment period closes on or before this date, ISO 8601 (YYYY-MM-DD). Use to find deadlines you need to act on soon.'),
+        per_page: z
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .optional()
+            .default(20)
+            .describe('Results per page (1–100, default 20).'),
+        page: z
+            .number()
+            .int()
+            .min(1)
+            .max(50)
+            .optional()
+            .default(1)
+            .describe('Page number (1–50). The FR caps total_pages at 50; with per_page=100 this covers up to 5,000 open rules.'),
+    }),
+    output: z.object({
+        asOf: z.string().describe('The "today" the open-window filter used (ISO 8601).'),
+        keyed: z
+            .boolean()
+            .describe('Whether comment counts were enriched (REGULATIONS_GOV_API_KEY present).'),
+        results: z
+            .array(z
+            .object({
+            documentNumber: z
+                .string()
+                .describe('Federal Register document number — chains into regulations_get_document.'),
+            title: z.string().describe('Rule title.'),
+            type: z.string().describe('Document type.'),
+            agencies: z.array(z.string()).describe('Issuing agency names.'),
+            publicationDate: z.string().describe('Publication date (ISO 8601).'),
+            commentsCloseOn: z.string().describe('Comment-period close date (ISO 8601).'),
+            daysRemaining: z
+                .number()
+                .describe('Whole days from asOf until the comment period closes.'),
+            docketIds: z
+                .array(z.string())
+                .describe('Docket IDs — chain into regulations_get_docket / find_comments.'),
+            commentCount: z
+                .number()
+                .nullable()
+                .describe("Comment count from the FR document's Regulations.gov info; null when unkeyed or not on Regulations.gov."),
+        })
+            .describe('One open-for-comment rule.'))
+            .describe('Rules open for comment (this page), closing soonest first.'),
+    }),
+    enrichment: {
+        totalCount: z.number().describe('Total rules open for comment matching the filters.'),
+        truncated: z
+            .boolean()
+            .optional()
+            .describe('True when matches exceed the FR 5,000-record navigation ceiling.'),
+        shown: z.number().optional().describe('Results returned on this page.'),
+        notice: z
+            .string()
+            .optional()
+            .describe('Guidance when nothing matched, or that comment counts are unavailable without a key.'),
+    },
+    errors: [
+        {
+            reason: 'no_results',
+            code: JsonRpcErrorCode.NotFound,
+            when: 'No rules open for comment match the filters.',
+            recovery: 'Drop the agency or closing_before filter — fewer rules are open than you might expect at any moment.',
+        },
+        {
+            reason: 'upstream_unavailable',
+            code: JsonRpcErrorCode.ServiceUnavailable,
+            when: 'Federal Register returned a 5xx, timed out, or served an HTML error page.',
+            recovery: 'Retry after a brief wait; the Federal Register API may be momentarily down.',
+        },
+    ],
+    async handler(input, ctx) {
+        const fr = getFederalRegisterService();
+        const keyed = getRegulationsGovService().hasKey();
+        const asOf = today();
+        const response = await fr.listOpenComments({
+            query: input.query || undefined,
+            agencies: input.agencies?.length ? input.agencies : undefined,
+            closingBefore: input.closing_before || undefined,
+            perPage: input.per_page,
+            page: input.page,
+        }, asOf, ctx);
+        ctx.enrich.total(response.totalCount);
+        if (response.results.length === 0) {
+            ctx.enrich.notice('No rules are open for comment matching the filters. Drop the agency or closing_before filter.');
+            return { asOf, keyed, results: [] };
+        }
+        const results = response.results
+            .map((r) => ({
+            documentNumber: r.documentNumber,
+            title: r.title,
+            type: r.type,
+            agencies: r.agencies,
+            publicationDate: r.publicationDate,
+            commentsCloseOn: r.commentsCloseOn,
+            daysRemaining: daysBetween(asOf, r.commentsCloseOn),
+            docketIds: r.docketIds,
+            // Counts come from the FR document's own regulations_dot_gov_info block;
+            // only surfaced when a key is configured (the degrade contract).
+            commentCount: keyed ? r.commentCount : null,
+        }))
+            .sort((a, b) => a.daysRemaining - b.daysRemaining);
+        if (!keyed) {
+            ctx.enrich.notice('Comment counts are unavailable without REGULATIONS_GOV_API_KEY (free at https://api.data.gov/signup/). The open-rule list itself is complete.');
+        }
+        else if (response.totalCount > FR_NAV_CEILING) {
+            ctx.enrich.truncated({
+                shown: results.length,
+                cap: FR_NAV_CEILING,
+                guidance: `${response.totalCount} open rules exceed the 5,000-record navigation ceiling. Narrow by agency or closing_before.`,
+            });
+        }
+        return { asOf, keyed, results };
+    },
+    format: (result) => {
+        const lines = [
+            `**Rules open for comment** (as of ${result.asOf} · keyed: ${result.keyed ? 'yes' : 'no — comment counts unavailable'})`,
+            '',
+        ];
+        lines.push('| Title | Type | Agency | Published | Closes | Days Left | Comments | Docket |');
+        lines.push('|---|---|---|---|---|---|---|---|');
+        for (const r of result.results) {
+            const agency = r.agencies[0] ?? '—';
+            const docket = r.docketIds[0] ?? '—';
+            const count = r.commentCount != null ? String(r.commentCount) : '—';
+            lines.push(`| ${escapePipes(r.title)} [FR ${r.documentNumber}] | ${r.type} | ${escapePipes(agency)} | ${r.publicationDate} | ${r.commentsCloseOn} | ${r.daysRemaining} | ${count} | ${docket} |`);
+        }
+        return [{ type: 'text', text: lines.join('\n') }];
+    },
+});
+//# sourceMappingURL=list-open-comments.tool.js.map