@cyanheads/secedgar-mcp-server 0.15.6 → 0.15.7

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

@@ -100,8 +100,15 @@ export declare function buildToolDefinitions(options: ToolDefinitionOptions): (i
 }, {
     readonly reason: "no_filings_found";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
-    readonly when: "No NPORT-P report exists for this fund, or none for the requested report_date";
+    readonly when: "No NPORT-P report exists for this fund, or none covers the report_date requested";
     readonly recovery: "Drop report_date to take the newest report, or use secedgar_search_filings with forms [\"NPORT-P\"] to see what the registrant has filed.";
+}, {
+    readonly reason: "rate_limited";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.RateLimited;
+    readonly when: "SEC is rate-limiting this server's IP — SEC answered 429, or the call was refused without being sent while the cool-down after one runs";
+    readonly recovery: "Wait the retryAfter seconds the error carries, then retry — SEC lifts the block only once requests stop for ten minutes.";
+    readonly retryable: true;
+    readonly thrownBy: "service";
 }], {
     readonly as_of: import("zod").ZodString;
     readonly notice: import("zod").ZodOptional<import("zod").ZodString>;
@@ -156,6 +163,13 @@ export declare function buildToolDefinitions(options: ToolDefinitionOptions): (i
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "The query is ambiguous and matches several companies";
     readonly recovery: "Retry with a ticker symbol or the 10-digit CIK from the matches list.";
+}, {
+    readonly reason: "rate_limited";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.RateLimited;
+    readonly when: "SEC is rate-limiting this server's IP — SEC answered 429, or the call was refused without being sent while the cool-down after one runs";
+    readonly recovery: "Wait the retryAfter seconds the error carries, then retry — SEC lifts the block only once requests stop for ten minutes.";
+    readonly retryable: true;
+    readonly thrownBy: "service";
 }], {
     readonly notice: import("zod").ZodOptional<import("zod").ZodString>;
     readonly truncated: import("zod").ZodOptional<import("zod").ZodBoolean>;
@@ -164,7 +178,7 @@ export declare function buildToolDefinitions(options: ToolDefinitionOptions): (i
 }> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
     query: import("zod").ZodString;
     include_filings: import("zod").ZodDefault<import("zod").ZodBoolean>;
-    form_types: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    forms: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
     filing_limit: import("zod").ZodDefault<import("zod").ZodNumber>;
     filed_after: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"">, import("zod").ZodString]>>;
     filed_before: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"">, import("zod").ZodString]>>;
@@ -205,6 +219,13 @@ export declare function buildToolDefinitions(options: ToolDefinitionOptions): (i
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Query is ambiguous and matches several companies";
     readonly recovery: "Specify a ticker symbol for an exact match instead of a name fragment.";
+}, {
+    readonly reason: "rate_limited";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.RateLimited;
+    readonly when: "SEC is rate-limiting this server's IP — SEC answered 429, or the call was refused without being sent while the cool-down after one runs";
+    readonly recovery: "Wait the retryAfter seconds the error carries, then retry — SEC lifts the block only once requests stop for ten minutes.";
+    readonly retryable: true;
+    readonly thrownBy: "service";
 }], {
     readonly notice: import("zod").ZodOptional<import("zod").ZodString>;
     readonly truncated: import("zod").ZodOptional<import("zod").ZodBoolean>;
@@ -213,8 +234,8 @@ export declare function buildToolDefinitions(options: ToolDefinitionOptions): (i
 }> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
     query: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"">, import("zod").ZodString]>>;
     forms: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-    start_date: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"">, import("zod").ZodString]>>;
-    end_date: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"">, import("zod").ZodString]>>;
+    filed_after: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"">, import("zod").ZodString]>>;
+    filed_before: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"">, import("zod").ZodString]>>;
     limit: import("zod").ZodDefault<import("zod").ZodNumber>;
     offset: import("zod").ZodDefault<import("zod").ZodNumber>;
     sort: import("zod").ZodDefault<import("zod").ZodEnum<{
@@ -258,23 +279,26 @@ export declare function buildToolDefinitions(options: ToolDefinitionOptions): (i
 }, import("zod/v4/core").$strip>, readonly [{
     readonly reason: "invalid_date_range";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
-    readonly when: "Only one of start_date or end_date was provided";
-    readonly recovery: "Provide both start_date and end_date, or omit both to search all dates.";
+    readonly when: "Only one of filed_after or filed_before was provided";
+    readonly recovery: "Provide both filed_after and filed_before, or omit both to search all dates.";
 }, {
     readonly reason: "unresolved_ticker";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "A ticker: targeting token in the query does not resolve to a known company";
     readonly recovery: "Verify the symbol with secedgar_company_search, or target by CIK with cik:<number> instead.";
+    readonly thrownBy: "service";
 }, {
     readonly reason: "invalid_cik";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "A cik: targeting token in the query is not a 1-10 digit number";
     readonly recovery: "Pass a numeric CIK such as cik:320193 — find it with secedgar_company_search if unknown.";
+    readonly thrownBy: "service";
 }, {
     readonly reason: "entity_not_found";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "A cik: targeting token on a pre-2001 date range names a CIK with no EDGAR submissions history";
     readonly recovery: "Confirm the CIK with secedgar_company_search — an accession-number prefix names the filing agent, not the issuer.";
+    readonly thrownBy: "service";
 }, {
     readonly reason: "missing_criteria";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
@@ -285,6 +309,13 @@ export declare function buildToolDefinitions(options: ToolDefinitionOptions): (i
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "A date range reaching before 2001-01-01 carries free-text terms with no entity scope — no pre-2001 full-text index exists, and nothing bounds a local scan";
     readonly recovery: "Add ticker: or cik: entity scope to the query, drop the text terms to browse by form and date, or start the range at 2001-01-01.";
+}, {
+    readonly reason: "rate_limited";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.RateLimited;
+    readonly when: "SEC is rate-limiting this server's IP — SEC answered 429, or the call was refused without being sent while the cool-down after one runs";
+    readonly recovery: "Wait the retryAfter seconds the error carries, then retry — SEC lifts the block only once requests stop for ten minutes.";
+    readonly retryable: true;
+    readonly thrownBy: "service";
 }], {
     readonly effectiveQuery: import("zod").ZodString;
     readonly notice: import("zod").ZodOptional<import("zod").ZodString>;
@@ -377,6 +408,13 @@ export declare function buildToolDefinitions(options: ToolDefinitionOptions): (i
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "The section string did not match any detected heading in the document";
     readonly recovery: "Pick a heading from the outline in the error message, or use offset paging instead.";
+}, {
+    readonly reason: "rate_limited";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.RateLimited;
+    readonly when: "SEC is rate-limiting this server's IP — SEC answered 429, or the call was refused without being sent while the cool-down after one runs";
+    readonly recovery: "Wait the retryAfter seconds the error carries, then retry — SEC lifts the block only once requests stop for ten minutes.";
+    readonly retryable: true;
+    readonly thrownBy: "service";
 }], {
     readonly notice: import("zod").ZodOptional<import("zod").ZodString>;
     readonly truncated: import("zod").ZodOptional<import("zod").ZodBoolean>;
@@ -446,6 +484,13 @@ export declare function buildToolDefinitions(options: ToolDefinitionOptions): (i
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Concept has data but the period_type filter excluded all of it";
     readonly recovery: "Switch period_type to \"quarterly\" or \"all\" for balance sheet items.";
+}, {
+    readonly reason: "rate_limited";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.RateLimited;
+    readonly when: "SEC is rate-limiting this server's IP — SEC answered 429, or the call was refused without being sent while the cool-down after one runs";
+    readonly recovery: "Wait the retryAfter seconds the error carries, then retry — SEC lifts the block only once requests stop for ten minutes.";
+    readonly retryable: true;
+    readonly thrownBy: "service";
 }], {
     readonly notice: import("zod").ZodOptional<import("zod").ZodString>;
     readonly truncated: import("zod").ZodOptional<import("zod").ZodBoolean>;
@@ -520,8 +565,15 @@ export declare function buildToolDefinitions(options: ToolDefinitionOptions): (i
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "The filer has no XBRL facts at all — pre-XBRL, foreign private issuer, or a non-operating registrant";
     readonly recovery: "Check the filer files XBRL financial statements, or read the filings directly with secedgar_search_filings.";
+}, {
+    readonly reason: "rate_limited";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.RateLimited;
+    readonly when: "SEC is rate-limiting this server's IP — SEC answered 429, or the call was refused without being sent while the cool-down after one runs";
+    readonly recovery: "Wait the retryAfter seconds the error carries, then retry — SEC lifts the block only once requests stop for ten minutes.";
+    readonly retryable: true;
+    readonly thrownBy: "service";
 }], undefined> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
-    ticker_or_cik: import("zod").ZodString;
+    company: import("zod").ZodString;
     transaction_type: import("zod").ZodDefault<import("zod").ZodEnum<{
         all: "all";
         purchase: "purchase";
@@ -566,20 +618,27 @@ export declare function buildToolDefinitions(options: ToolDefinitionOptions): (i
 }, import("zod/v4/core").$strip>, readonly [{
     readonly reason: "company_not_found";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
-    readonly when: "The ticker or CIK does not resolve to a known company";
+    readonly when: "The company input does not resolve to a known company";
     readonly recovery: "Use secedgar_company_search to find the correct ticker or CIK.";
 }, {
     readonly reason: "no_filings_found";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "No Form 4 filings exist for this company in the recent submissions window";
     readonly recovery: "Use secedgar_search_filings with forms=[\"4\"] for broader historical coverage.";
+}, {
+    readonly reason: "rate_limited";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.RateLimited;
+    readonly when: "SEC is rate-limiting this server's IP — SEC answered 429, or the call was refused without being sent while the cool-down after one runs";
+    readonly recovery: "Wait the retryAfter seconds the error carries, then retry — SEC lifts the block only once requests stop for ten minutes.";
+    readonly retryable: true;
+    readonly thrownBy: "service";
 }], {
     readonly notice: import("zod").ZodOptional<import("zod").ZodString>;
     readonly truncated: import("zod").ZodOptional<import("zod").ZodBoolean>;
     readonly shown: import("zod").ZodOptional<import("zod").ZodNumber>;
     readonly cap: import("zod").ZodOptional<import("zod").ZodNumber>;
 }> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
-    ticker_or_cik: import("zod").ZodString;
+    company: import("zod").ZodString;
     quarter: import("zod").ZodOptional<import("zod").ZodString>;
     limit: import("zod").ZodDefault<import("zod").ZodNumber>;
     offset: import("zod").ZodDefault<import("zod").ZodNumber>;
@@ -622,7 +681,7 @@ export declare function buildToolDefinitions(options: ToolDefinitionOptions): (i
 }, import("zod/v4/core").$strip>, readonly [{
     readonly reason: "company_not_found";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
-    readonly when: "The ticker or CIK does not resolve to a known company or institution";
+    readonly when: "The company input does not resolve to a known company or institution";
     readonly recovery: "Use secedgar_company_search to find the correct CIK or full entity name.";
 }, {
     readonly reason: "ambiguous_entity";
@@ -639,6 +698,13 @@ export declare function buildToolDefinitions(options: ToolDefinitionOptions): (i
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "The 13F-HR filing was found but the information table XML document could not be located";
     readonly recovery: "Use secedgar_get_filing with the accession number to inspect the filing documents directly.";
+}, {
+    readonly reason: "rate_limited";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.RateLimited;
+    readonly when: "SEC is rate-limiting this server's IP — SEC answered 429, or the call was refused without being sent while the cool-down after one runs";
+    readonly recovery: "Wait the retryAfter seconds the error carries, then retry — SEC lifts the block only once requests stop for ten minutes.";
+    readonly retryable: true;
+    readonly thrownBy: "service";
 }], {
     readonly notice: import("zod").ZodOptional<import("zod").ZodString>;
     readonly truncated: import("zod").ZodOptional<import("zod").ZodBoolean>;
@@ -688,6 +754,13 @@ export declare function buildToolDefinitions(options: ToolDefinitionOptions): (i
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "The issuer name matches several EDGAR companies and no cusip was given";
     readonly recovery: "Retry with the ticker or the 10-digit CIK of the intended issuer from the matches list.";
+}, {
+    readonly reason: "rate_limited";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.RateLimited;
+    readonly when: "SEC is rate-limiting this server's IP — SEC answered 429, or the call was refused without being sent while the cool-down after one runs";
+    readonly recovery: "Wait the retryAfter seconds the error carries, then retry — SEC lifts the block only once requests stop for ten minutes.";
+    readonly retryable: true;
+    readonly thrownBy: "service";
 }], {
     readonly ordering: import("zod").ZodString;
     readonly notice: import("zod").ZodOptional<import("zod").ZodString>;
@@ -767,6 +840,13 @@ export declare function buildToolDefinitions(options: ToolDefinitionOptions): (i
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "The issuer has no structured SCHEDULE 13D/13G filings matching the requested form kind";
     readonly recovery: "Use secedgar_search_filings with forms [\"SC 13D\",\"SC 13G\"] to reach the pre-2024-12-18 text filings, then read them with secedgar_get_filing.";
+}, {
+    readonly reason: "rate_limited";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.RateLimited;
+    readonly when: "SEC is rate-limiting this server's IP — SEC answered 429, or the call was refused without being sent while the cool-down after one runs";
+    readonly recovery: "Wait the retryAfter seconds the error carries, then retry — SEC lifts the block only once requests stop for ten minutes.";
+    readonly retryable: true;
+    readonly thrownBy: "service";
 }], {
     readonly notice: import("zod").ZodOptional<import("zod").ZodString>;
     readonly truncated: import("zod").ZodOptional<import("zod").ZodBoolean>;
@@ -837,6 +917,13 @@ export declare function buildToolDefinitions(options: ToolDefinitionOptions): (i
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Concept resolves but no companies report this metric for the requested period and unit";
     readonly recovery: "Check duration vs instant period, unit, and that the period exists post-CY2009.";
+}, {
+    readonly reason: "rate_limited";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.RateLimited;
+    readonly when: "SEC is rate-limiting this server's IP — SEC answered 429, or the call was refused without being sent while the cool-down after one runs";
+    readonly recovery: "Wait the retryAfter seconds the error carries, then retry — SEC lifts the block only once requests stop for ten minutes.";
+    readonly retryable: true;
+    readonly thrownBy: "service";
 }], {
     readonly notice: import("zod").ZodOptional<import("zod").ZodString>;
     readonly truncated: import("zod").ZodOptional<import("zod").ZodBoolean>;
@@ -914,6 +1001,13 @@ export declare function buildToolDefinitions(options: ToolDefinitionOptions): (i
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Companies resolved but not one of them reports any of the requested concepts for the requested period type";
     readonly recovery: "Switch period_type, or discover reported concept names with secedgar_search_concepts.";
+}, {
+    readonly reason: "rate_limited";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.RateLimited;
+    readonly when: "SEC is rate-limiting this server's IP — SEC answered 429, or the call was refused without being sent while the cool-down after one runs";
+    readonly recovery: "Wait the retryAfter seconds the error carries, then retry — SEC lifts the block only once requests stop for ten minutes.";
+    readonly retryable: true;
+    readonly thrownBy: "service";
 }], {
     readonly notice: import("zod").ZodOptional<import("zod").ZodString>;
     readonly truncated: import("zod").ZodOptional<import("zod").ZodBoolean>;
@@ -1005,26 +1099,55 @@ export declare function buildToolDefinitions(options: ToolDefinitionOptions): (i
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "The SQL query references a denied DuckDB system catalog (information_schema, pg_catalog, sqlite_master, duckdb_*)";
     readonly recovery: "Query only df_<id> tables. Use secedgar_dataframe_describe to list available dataframes.";
+    readonly thrownBy: "service";
 }, {
     readonly reason: "missing_table";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "The SQL query references a df_<id> table that does not exist or has expired";
     readonly recovery: "Use secedgar_dataframe_describe to list available dataframes and verify the table name.";
+    readonly thrownBy: "service";
 }, {
     readonly reason: "invalid_sql";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
-    readonly when: "The SQL statement contains a syntax or execution error not covered by a more specific reason";
+    readonly when: "The SELECT fails to prepare — an unknown column or an invalid expression — or hits an engine error no more specific reason covers";
     readonly recovery: "Check SQL syntax, column names, and table references against secedgar_dataframe_describe.";
+    readonly thrownBy: "service";
+}, {
+    readonly reason: "sql_execution_error";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "The SELECT prepared but failed on the data it read — a cast or conversion that does not fit, an out-of-range value, or invalid input to a function";
+    readonly recovery: "Wrap the failing cast in TRY_CAST, or filter out the rows the error message names before converting them.";
+    readonly thrownBy: "service";
 }, {
     readonly reason: "register_as_clash";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "The register_as target name already exists on the canvas";
     readonly recovery: "Drop the existing dataframe with secedgar_dataframe_drop (when enabled), choose a different df_XXXXX_XXXXX name, or omit register_as.";
+    readonly thrownBy: "service";
 }, {
     readonly reason: "non_select_statement";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
-    readonly when: "The SQL is a non-SELECT statement (DROP, INSERT, UPDATE, DDL, etc.) — only read-only SELECTs run against dataframes";
+    readonly when: "The SQL is not a SELECT (DROP, INSERT, UPDATE, DDL, PRAGMA, EXPLAIN, etc.) or does not parse — only read-only SELECTs run against dataframes";
     readonly recovery: "Query only SELECT statements against df_<id> tables. Use secedgar_dataframe_describe to inspect available dataframes.";
+    readonly thrownBy: "service";
+}, {
+    readonly reason: "multi_statement";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "The SQL holds more than one statement";
+    readonly recovery: "Send exactly one SELECT statement per call, and split multi-statement SQL into separate calls.";
+    readonly thrownBy: "service";
+}, {
+    readonly reason: "denied_function";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "The SQL calls a file-reading or external-data table function such as read_csv, read_parquet, or glob";
+    readonly recovery: "Remove the file-reading function and query only the df_<id> tables secedgar_dataframe_describe lists.";
+    readonly thrownBy: "service";
+}, {
+    readonly reason: "plan_operator_not_allowed";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "The query plan uses an operator outside the read-only allowlist, such as the range() or generate_series() table functions";
+    readonly recovery: "Rewrite with read-only SELECT constructs — joins, aggregates, window functions, CTEs, and unnest() are supported.";
+    readonly thrownBy: "service";
 }], {
     readonly notice: import("zod").ZodOptional<import("zod").ZodString>;
     readonly truncated: import("zod").ZodOptional<import("zod").ZodBoolean>;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAqBH,4EAA4E;AAC5E,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,WAAW,EAAE,OAAO,CAAC;CACtB;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA0BlE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAqBH,4EAA4E;AAC5E,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,WAAW,EAAE,OAAO,CAAC;CACtB;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA0BlE"}

package/dist/mcp-server/tools/definitions/search-filings.tool.d.ts

@@ -10,8 +10,8 @@ import { JsonRpcErrorCode } from '@cyanheads/mcp-ts-core/errors';
 export declare const searchFilingsTool: import("@cyanheads/mcp-ts-core").ToolDefinition<z.ZodObject<{
     query: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodString]>>;
     forms: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    start_date: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodString]>>;
-    end_date: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodString]>>;
+    filed_after: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodString]>>;
+    filed_before: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodString]>>;
     limit: z.ZodDefault<z.ZodNumber>;
     offset: z.ZodDefault<z.ZodNumber>;
     sort: z.ZodDefault<z.ZodEnum<{
@@ -55,23 +55,26 @@ export declare const searchFilingsTool: import("@cyanheads/mcp-ts-core").ToolDef
 }, z.core.$strip>, readonly [{
     readonly reason: "invalid_date_range";
     readonly code: JsonRpcErrorCode.ValidationError;
-    readonly when: "Only one of start_date or end_date was provided";
-    readonly recovery: "Provide both start_date and end_date, or omit both to search all dates.";
+    readonly when: "Only one of filed_after or filed_before was provided";
+    readonly recovery: "Provide both filed_after and filed_before, or omit both to search all dates.";
 }, {
     readonly reason: "unresolved_ticker";
     readonly code: JsonRpcErrorCode.ValidationError;
     readonly when: "A ticker: targeting token in the query does not resolve to a known company";
     readonly recovery: "Verify the symbol with secedgar_company_search, or target by CIK with cik:<number> instead.";
+    readonly thrownBy: "service";
 }, {
     readonly reason: "invalid_cik";
     readonly code: JsonRpcErrorCode.ValidationError;
     readonly when: "A cik: targeting token in the query is not a 1-10 digit number";
     readonly recovery: "Pass a numeric CIK such as cik:320193 — find it with secedgar_company_search if unknown.";
+    readonly thrownBy: "service";
 }, {
     readonly reason: "entity_not_found";
     readonly code: JsonRpcErrorCode.NotFound;
     readonly when: "A cik: targeting token on a pre-2001 date range names a CIK with no EDGAR submissions history";
     readonly recovery: "Confirm the CIK with secedgar_company_search — an accession-number prefix names the filing agent, not the issuer.";
+    readonly thrownBy: "service";
 }, {
     readonly reason: "missing_criteria";
     readonly code: JsonRpcErrorCode.ValidationError;
@@ -82,6 +85,13 @@ export declare const searchFilingsTool: import("@cyanheads/mcp-ts-core").ToolDef
     readonly code: JsonRpcErrorCode.ValidationError;
     readonly when: "A date range reaching before 2001-01-01 carries free-text terms with no entity scope — no pre-2001 full-text index exists, and nothing bounds a local scan";
     readonly recovery: "Add ticker: or cik: entity scope to the query, drop the text terms to browse by form and date, or start the range at 2001-01-01.";
+}, {
+    readonly reason: "rate_limited";
+    readonly code: JsonRpcErrorCode.RateLimited;
+    readonly when: "SEC is rate-limiting this server's IP — SEC answered 429, or the call was refused without being sent while the cool-down after one runs";
+    readonly recovery: "Wait the retryAfter seconds the error carries, then retry — SEC lifts the block only once requests stop for ten minutes.";
+    readonly retryable: true;
+    readonly thrownBy: "service";
 }], {
     readonly effectiveQuery: z.ZodString;
     readonly notice: z.ZodOptional<z.ZodString>;

package/dist/mcp-server/tools/definitions/search-filings.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search-filings.tool.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/search-filings.tool.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAsB,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EACL,gBAAgB,EAIjB,MAAM,+BAA+B,CAAC;AA0lBvC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAslB5B,CAAC"}
+{"version":3,"file":"search-filings.tool.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/search-filings.tool.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAsB,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EACL,gBAAgB,EAIjB,MAAM,+BAA+B,CAAC;AA0lBvC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0mB5B,CAAC"}

package/dist/mcp-server/tools/definitions/search-filings.tool.js

@@ -465,26 +465,29 @@ export const searchFilingsTool = tool('secedgar_search_filings', {
         {
             reason: 'invalid_date_range',
             code: JsonRpcErrorCode.ValidationError,
-            when: 'Only one of start_date or end_date was provided',
-            recovery: 'Provide both start_date and end_date, or omit both to search all dates.',
+            when: 'Only one of filed_after or filed_before was provided',
+            recovery: 'Provide both filed_after and filed_before, or omit both to search all dates.',
         },
         {
             reason: 'unresolved_ticker',
             code: JsonRpcErrorCode.ValidationError,
             when: 'A ticker: targeting token in the query does not resolve to a known company',
             recovery: 'Verify the symbol with secedgar_company_search, or target by CIK with cik:<number> instead.',
+            thrownBy: 'service',
         },
         {
             reason: 'invalid_cik',
             code: JsonRpcErrorCode.ValidationError,
             when: 'A cik: targeting token in the query is not a 1-10 digit number',
             recovery: 'Pass a numeric CIK such as cik:320193 — find it with secedgar_company_search if unknown.',
+            thrownBy: 'service',
         },
         {
             reason: 'entity_not_found',
             code: JsonRpcErrorCode.NotFound,
             when: 'A cik: targeting token on a pre-2001 date range names a CIK with no EDGAR submissions history',
             recovery: 'Confirm the CIK with secedgar_company_search — an accession-number prefix names the filing agent, not the issuer.',
+            thrownBy: 'service',
         },
         {
             reason: 'missing_criteria',
@@ -498,6 +501,14 @@ export const searchFilingsTool = tool('secedgar_search_filings', {
             when: 'A date range reaching before 2001-01-01 carries free-text terms with no entity scope — no pre-2001 full-text index exists, and nothing bounds a local scan',
             recovery: 'Add ticker: or cik: entity scope to the query, drop the text terms to browse by form and date, or start the range at 2001-01-01.',
         },
+        {
+            reason: 'rate_limited',
+            code: JsonRpcErrorCode.RateLimited,
+            when: "SEC is rate-limiting this server's IP — SEC answered 429, or the call was refused without being sent while the cool-down after one runs",
+            recovery: 'Wait the retryAfter seconds the error carries, then retry — SEC lifts the block only once requests stop for ten minutes.',
+            retryable: true,
+            thrownBy: 'service',
+        },
     ],
     input: z.object({
         query: z
@@ -515,7 +526,7 @@ export const searchFilingsTool = tool('secedgar_search_filings', {
             .array(z.string())
             .optional()
             .describe('Filter to specific form types (e.g., ["10-K", "10-Q", "8-K"]). Without this, searches all form types. Note: "10-K" also matches amendments filed as 10-K/A. SEC renamed the blockholder schedules on 2024-12-18 — filings before that date are "SC 13D"/"SC 13G", filings after are "SCHEDULE 13D"/"SCHEDULE 13G" — so a filter spanning that boundary must list both spellings. Ownership forms (3, 4, 5) are indexed by the reporting person (e.g., "LEVINSON ARTHUR D"), not the issuer — rows carry no transaction code, share count, or price. Use secedgar_get_insider_transactions to retrieve parsed ownership XML with person, relationship, transaction code, shares, and price.'),
-        start_date: z
+        filed_after: z
             .union([
             z.literal(''),
             z
@@ -524,8 +535,8 @@ export const searchFilingsTool = tool('secedgar_search_filings', {
                 .describe('YYYY-MM-DD'),
         ])
             .optional()
-            .describe('Start of date range (YYYY-MM-DD). Both start_date and end_date must be provided for date filtering.'),
-        end_date: z
+            .describe('Only include filings filed on or after this date (YYYY-MM-DD). This tool filters by date only with both bounds — pair it with filed_before.'),
+        filed_before: z
             .union([
             z.literal(''),
             z
@@ -534,7 +545,7 @@ export const searchFilingsTool = tool('secedgar_search_filings', {
                 .describe('YYYY-MM-DD'),
         ])
             .optional()
-            .describe('End of date range (YYYY-MM-DD). Both start_date and end_date must be provided for date filtering.'),
+            .describe('Only include filings filed on or before this date (YYYY-MM-DD). This tool filters by date only with both bounds — pair it with filed_after.'),
         limit: z.number().int().min(1).max(100).default(20).describe('Results per page. Max 100.'),
         offset: z
             .number()
@@ -548,6 +559,14 @@ export const searchFilingsTool = tool('secedgar_search_filings', {
             .default('filing_date_desc')
             .describe('Result ordering. "filing_date_desc" (default) returns most recent first. "filing_date_asc" returns oldest first. "relevance" returns SEC\'s native search-score order, which weights term match strength over recency. Date sorts re-order the top 100 hits returned by the search index — for broad queries with more than 100 matches and no entity targeting, date-newest filings may sit outside that window. Entity targeting (ticker:/cik:) or a narrower query keeps matches inside the window when absolute recency matters. On the no-query browse path (forms/entity only), EFTS has no relevance signal — every hit scores null — and returns filings in natural date-descending order, so all sort modes effectively yield newest-first. Pre-2001 archive results carry no relevance score either, so relevance collapses to date-descending there.'),
     }),
+    // This tool's former date spellings, and other spellings in use across tools (#115).
+    inputAliases: {
+        start_date: 'filed_after',
+        date_from: 'filed_after',
+        end_date: 'filed_before',
+        date_to: 'filed_before',
+        form_types: 'forms',
+    },
     output: z.object({
         total: z
             .number()
@@ -632,8 +651,8 @@ export const searchFilingsTool = tool('secedgar_search_filings', {
     }),
     async handler(input, ctx) {
         // Validate date range: both or neither
-        if ((input.start_date && !input.end_date) || (!input.start_date && input.end_date)) {
-            throw ctx.fail('invalid_date_range', 'Both start_date and end_date are required when filtering by date.', { ...ctx.recoveryFor('invalid_date_range') });
+        if ((input.filed_after && !input.filed_before) || (!input.filed_after && input.filed_before)) {
+            throw ctx.fail('invalid_date_range', 'Both filed_after and filed_before are required when filtering by date.', { ...ctx.recoveryFor('invalid_date_range') });
         }
         // Browse mode (#79): EFTS accepts a forms-only or entity-scoped request with no
         // full-text term, but rejects one with neither ("Blank search not valid"). Guard
@@ -652,8 +671,8 @@ export const searchFilingsTool = tool('secedgar_search_filings', {
         // indexes filings from 2001, so a range reaching earlier is served from the
         // archives — entirely, or (when it also reaches 2001 onward) as the older half
         // of a two-source merge split at the floor (#77, #87).
-        const startDate = input.start_date || undefined;
-        const endDate = input.end_date || undefined;
+        const startDate = input.filed_after || undefined;
+        const endDate = input.filed_before || undefined;
         const hasFreeText = query.trim().length > 0;
         if (startDate && endDate && startDate < EFTS_FULLTEXT_FLOOR) {
             const straddles = endDate >= EFTS_FULLTEXT_FLOOR;
@@ -730,8 +749,8 @@ export const searchFilingsTool = tool('secedgar_search_filings', {
                     query: hasFreeText ? query : undefined,
                     entity_cik: entityCik,
                     forms: input.forms,
-                    start_date: startDate,
-                    end_date: endDate,
+                    filed_after: startDate,
+                    filed_before: endDate,
                     source: straddles ? 'efts+archive' : entityCik ? 'submissions' : 'full-index',
                 },
                 effectiveQuery: straddles
@@ -760,8 +779,8 @@ export const searchFilingsTool = tool('secedgar_search_filings', {
             query,
             forms: input.forms,
             ciks: entityCik ? [entityCik] : undefined,
-            startDate: input.start_date,
-            endDate: input.end_date,
+            startDate: input.filed_after,
+            endDate: input.filed_before,
             from: fetchFrom,
             size: fetchSize,
         });
@@ -830,8 +849,8 @@ export const searchFilingsTool = tool('secedgar_search_filings', {
                 queryParams: {
                     query,
                     forms: input.forms,
-                    start_date: input.start_date,
-                    end_date: input.end_date,
+                    filed_after: input.filed_after,
+                    filed_before: input.filed_before,
                     entity_cik: entityCik,
                     source: 'efts',
                 },
@@ -861,8 +880,8 @@ export const searchFilingsTool = tool('secedgar_search_filings', {
                 criteria.push(`entity CIK ${entityCik}`);
             if (input.forms?.length)
                 criteria.push(`forms [${input.forms.join(', ')}]`);
-            if (input.start_date && input.end_date) {
-                criteria.push(`dates ${input.start_date} to ${input.end_date}`);
+            if (input.filed_after && input.filed_before) {
+                criteria.push(`dates ${input.filed_after} to ${input.filed_before}`);
             }
             const criteriaText = criteria.length > 0 ? criteria.join(', ') : 'the given criteria';
             ctx.enrich.notice(`No filings matched ${criteriaText}. Broaden the query, remove the form filter, or widen the date range.`);