@cyanheads/secedgar-mcp-server 0.19.0 → 0.19.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/AGENTS.md +15 -6
- package/CLAUDE.md +15 -6
- package/README.md +3 -1
- package/changelog/0.19.x/0.19.1.md +35 -0
- package/dist/mcp-server/tools/definitions/company-search.tool.d.ts +16 -2
- package/dist/mcp-server/tools/definitions/company-search.tool.d.ts.map +1 -1
- package/dist/mcp-server/tools/definitions/company-search.tool.js +177 -32
- package/dist/mcp-server/tools/definitions/company-search.tool.js.map +1 -1
- package/dist/mcp-server/tools/definitions/find-holders.tool.d.ts +8 -8
- package/dist/mcp-server/tools/definitions/find-holders.tool.d.ts.map +1 -1
- package/dist/mcp-server/tools/definitions/find-holders.tool.js +2 -9
- package/dist/mcp-server/tools/definitions/find-holders.tool.js.map +1 -1
- package/dist/mcp-server/tools/definitions/get-institutional-holdings.tool.d.ts +8 -8
- package/dist/mcp-server/tools/definitions/get-institutional-holdings.tool.d.ts.map +1 -1
- package/dist/mcp-server/tools/definitions/get-institutional-holdings.tool.js +3 -10
- package/dist/mcp-server/tools/definitions/get-institutional-holdings.tool.js.map +1 -1
- package/dist/mcp-server/tools/definitions/index.d.ts +20 -13
- package/dist/mcp-server/tools/definitions/index.d.ts.map +1 -1
- package/dist/mcp-server/tools/definitions/search-filings.tool.d.ts +8 -8
- package/dist/mcp-server/tools/definitions/search-filings.tool.d.ts.map +1 -1
- package/dist/mcp-server/tools/definitions/search-filings.tool.js +4 -11
- package/dist/mcp-server/tools/definitions/search-filings.tool.js.map +1 -1
- package/dist/mcp-server/tools/resolved-as.d.ts +4 -2
- package/dist/mcp-server/tools/resolved-as.d.ts.map +1 -1
- package/dist/mcp-server/tools/resolved-as.js +5 -3
- package/dist/mcp-server/tools/resolved-as.js.map +1 -1
- package/dist/mcp-server/tools/sec-upstream-errors.d.ts +15 -1
- package/dist/mcp-server/tools/sec-upstream-errors.d.ts.map +1 -1
- package/dist/mcp-server/tools/sec-upstream-errors.js +15 -1
- package/dist/mcp-server/tools/sec-upstream-errors.js.map +1 -1
- package/dist/services/edgar/data/former-tickers.json +24159 -0
- package/dist/services/edgar/edgar-api-service.d.ts +92 -16
- package/dist/services/edgar/edgar-api-service.d.ts.map +1 -1
- package/dist/services/edgar/edgar-api-service.js +268 -69
- package/dist/services/edgar/edgar-api-service.js.map +1 -1
- package/dist/services/edgar/former-tickers.d.ts +47 -0
- package/dist/services/edgar/former-tickers.d.ts.map +1 -0
- package/dist/services/edgar/former-tickers.js +77 -0
- package/dist/services/edgar/former-tickers.js.map +1 -0
- package/dist/services/edgar/types.d.ts +9 -4
- package/dist/services/edgar/types.d.ts.map +1 -1
- package/package.json +4 -3
- package/server.json +3 -3
- package/skills/secedgar-guide/SKILL.md +1 -1
package/AGENTS.md
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
# Agent Protocol
|
|
2
2
|
|
|
3
3
|
**Server:** secedgar-mcp-server
|
|
4
|
-
**Version:** 0.19.
|
|
4
|
+
**Version:** 0.19.1
|
|
5
5
|
**Framework:** [@cyanheads/mcp-ts-core](https://www.npmjs.com/package/@cyanheads/mcp-ts-core) `^0.13.22`
|
|
6
6
|
**Engines:** Bun ≥1.4.4, Node ≥24.0.0
|
|
7
7
|
**MCP SDK:** `@modelcontextprotocol/server` ^2.4.0
|
|
@@ -82,14 +82,15 @@ Tailor suggestions to what's actually missing or stale — don't recite the full
|
|
|
82
82
|
|
|
83
83
|
## Domain Notes
|
|
84
84
|
|
|
85
|
-
- **Rate limit:** 10 req/s per IP. Every SEC request goes through one process-wide `createPacer` queue in `EdgarApiService` that spaces request *starts* `1000 / EDGAR_RATE_LIMIT_RPS` ms apart, with no concurrency cap and no wait budget — an ordinary burst drains at the configured rate and is never shed, and this server's own traffic can never exceed it, so `rateLimitRps` stays at 10 and headroom for a co-tenant on the outbound IP is the operator's call via `EDGAR_RATE_LIMIT_RPS`. A 429 is **not** retried: SEC holds the block until the request rate has stayed under the threshold for ten minutes and every request sent meanwhile restarts that clock, so the ~3s retry budget (`MAX_RETRIES` 3 × `BASE_BACKOFF_MS` 1000, exponential) cannot outlast it (#112). Instead a 429 closes the service's **block gate** for `EDGAR_RATE_LIMIT_COOLDOWN_SECONDS` (default 600). While it is closed nothing is sent: a call fails locally as `RateLimited` with `retryAfter` set to the whole seconds remaining (never below 1), and the gate is re-read at dispatch, so a call already queued in the pacer when the 429 landed — or a 5xx, no-response, or body-failure retry sleeping through its backoff — is refused too. The first call after the cool-down is sent alone as a probe while every other call waits on it: any HTTP answer but a 429 reopens normal pacing, a probe 429 closes the gate for the full cool-down again, and a probe that gets no HTTP answer (a network error, or no headers within the per-attempt cap) proves nothing, so the next call probes in its place — and every call that waited on it counts that probe as one of its own no-response attempts, so calls queued behind a silent SEC each settle within their own three-attempt ladder instead of probing in turn, 15 s apiece (#173). **The gate lives in the service, not in the pacer's `cooldown` option** — that gate holds queued calls until it reopens and then releases them all at the pacing rate, so it can neither refuse locally nor keep the reopening to one request. The upstream 429 and the local refusal carry one `data.reason: 'rate_limited'`, declared (`thrownBy: 'service'`, `retryable: true`) on every tool that reaches SEC, plus `data.retryable: true` — `ctx.fail` copies a contract entry's `retryable` onto `data`, a service throw does not, so both throw sites set it themselves (#122) — and one recovery hint naming SEC's ten-minute window and the seconds to wait; SEC's HTML block page stays out of the payload: the 429's body is cancelled unread (#188). Reads the local mirror can answer keep answering during a block: their live reads (the ticker file, a filer's submissions or point read, an open period's frame) are refused locally like any other, and the mirror answers in their place (Local mirror below). 500/502/503/504 still retry with the backoff, and so does an attempt that gets no HTTP response at all — a `fetch` rejection (Bun sets the transport code on the error itself, Node's undici on its `cause`) or no response headers within `ATTEMPT_HEADERS_TIMEOUT_MS` (15 s from dispatch; pacer queue time and the body read are outside it) (#173). Each tool call's `CallScope` carries a failure budget, `CALL_FAILURE_BUDGET_MS` (40 s, `call-scope.ts`): the time SEC spends failing the call — unanswered-attempt and 5xx waits, backoff, body-idle time — is charged to it and healthy progress never is, attempt and body-idle waits are clamped to what is left, a backoff is slept only while the budget outlasts it, and once it is spent no further attempt or backoff starts and the request fails as `sec_unreachable` or, after a 5xx, `sec_unavailable`, so a call against an unresponsive SEC settles inside the MCP client's 60 s default; the caller's `ctx.signal` reaches every pacer wait, fetch, body read, and backoff, and a cancel rethrows untouched, never retried or counted as an SEC failure (#179). Every body is read inside that ladder, in `rawFetch`'s one body reader (`readBody`), so a 2xx whose body fails after its headers — the connection breaks off, invalid chunk framing or compression, or no bytes for `BODY_IDLE_TIMEOUT_MS` (15 s between reads, never across the whole body, so a body still arriving is never cut) — retries the same way; a probe whose headers arrive has already reopened the gate, and only its own call retries the body. The error body is read there too: a non-retryable status's or a last-attempt 5xx's body is captured
|
|
85
|
+
- **Rate limit:** 10 req/s per IP. Every SEC request goes through one process-wide `createPacer` queue in `EdgarApiService` that spaces request *starts* `1000 / EDGAR_RATE_LIMIT_RPS` ms apart, with no concurrency cap and no wait budget — an ordinary burst drains at the configured rate and is never shed, and this server's own traffic can never exceed it, so `rateLimitRps` stays at 10 and headroom for a co-tenant on the outbound IP is the operator's call via `EDGAR_RATE_LIMIT_RPS`. A 429 is **not** retried: SEC holds the block until the request rate has stayed under the threshold for ten minutes and every request sent meanwhile restarts that clock, so the ~3s retry budget (`MAX_RETRIES` 3 × `BASE_BACKOFF_MS` 1000, exponential) cannot outlast it (#112). Instead a 429 closes the service's **block gate** for `EDGAR_RATE_LIMIT_COOLDOWN_SECONDS` (default 600). While it is closed nothing is sent: a call fails locally as `RateLimited` with `retryAfter` set to the whole seconds remaining (never below 1), and the gate is re-read at dispatch, so a call already queued in the pacer when the 429 landed — or a 5xx, no-response, or body-failure retry sleeping through its backoff — is refused too. The first call after the cool-down is sent alone as a probe while every other call waits on it: any HTTP answer but a 429 reopens normal pacing, a probe 429 closes the gate for the full cool-down again, and a probe that gets no HTTP answer (a network error, or no headers within the per-attempt cap) proves nothing, so the next call probes in its place — and every call that waited on it counts that probe as one of its own no-response attempts, so calls queued behind a silent SEC each settle within their own three-attempt ladder instead of probing in turn, 15 s apiece (#173). **The gate lives in the service, not in the pacer's `cooldown` option** — that gate holds queued calls until it reopens and then releases them all at the pacing rate, so it can neither refuse locally nor keep the reopening to one request. The upstream 429 and the local refusal carry one `data.reason: 'rate_limited'`, declared (`thrownBy: 'service'`, `retryable: true`) on every tool that reaches SEC, plus `data.retryable: true` — `ctx.fail` copies a contract entry's `retryable` onto `data`, a service throw does not, so both throw sites set it themselves (#122) — and one recovery hint naming SEC's ten-minute window and the seconds to wait; SEC's HTML block page stays out of the payload: the 429's body is cancelled unread (#188). Reads the local mirror can answer keep answering during a block: their live reads (the ticker file, a filer's submissions or point read, an open period's frame) are refused locally like any other, and the mirror answers in their place (Local mirror below). 500/502/503/504 still retry with the backoff, and so does an attempt that gets no HTTP response at all — a `fetch` rejection (Bun sets the transport code on the error itself, Node's undici on its `cause`) or no response headers within `ATTEMPT_HEADERS_TIMEOUT_MS` (15 s from dispatch; pacer queue time and the body read are outside it) (#173). Each tool call's `CallScope` carries a failure budget, `CALL_FAILURE_BUDGET_MS` (40 s, `call-scope.ts`): the time SEC spends failing the call — unanswered-attempt and 5xx waits, backoff, body-idle time — is charged to it and healthy progress never is, attempt and body-idle waits are clamped to what is left, a backoff is slept only while the budget outlasts it, and once it is spent no further attempt or backoff starts and the request fails as `sec_unreachable` or, after a 5xx, `sec_unavailable`, so a call against an unresponsive SEC settles inside the MCP client's 60 s default; the caller's `ctx.signal` reaches every pacer wait, fetch, body read, and backoff, and a cancel rethrows untouched, never retried or counted as an SEC failure (#179). Every body is read inside that ladder, in `rawFetch`'s one body reader (`readBody`), so a 2xx whose body fails after its headers — the connection breaks off, invalid chunk framing or compression, or no bytes for `BODY_IDLE_TIMEOUT_MS` (15 s between reads, never across the whole body, so a body still arriving is never cut) — retries the same way; a probe whose headers arrive has already reopened the gate, and only its own call retries the body. The error body is read there too: a non-retryable status's or a last-attempt 5xx's body is captured through `readBody` (`errorBodyHead`: the first 500 bytes, `…` when cut short, never a partial code point) as a log-only diagnostic — it rides the error's `cause`, whose `data` the call's failure log record writes, never the error's own `data`, which the caller receives (#244) — so one that stalls after its headers ends at the 15 s idle limit or the budget left — keeping what arrived, its wait charged to the budget — and the caller's cancel ends it at once as cancellation (#202). A body the ladder has no use for — a 404's, a retried 5xx's (released before its backoff), a 429's, an answer landing as the caller cancels — is cancelled unread (#188); an error a spent budget ends with from a retried 5xx therefore logs no body. A 200 that reads whole but is not JSON where JSON is expected fails on its one request, unretried (#181). EDGAR full-text search answers a failure of its search backend with a 200 whose JSON carries `errorType` (its OpenSearch client's error class) in place of hits; `searchFilings` and `resolveEntityByName` opt in to classifying that body (`ReadOptions.backendFailure`), so `ConnectionError`, `TimeoutError`, and `NoLivingConnectionsError` fail the attempt on this ladder like a 5xx — same attempts, backoff, block-gate and pacer re-admission, budget, and cancel — and end as `efts_degraded_response` with `retryable: true`, while any other `errorType` (a `ResponseError` is the cluster refusing the request) fails on its one request with `retryable: false`; both carry `upstreamErrorType` and `upstreamErrorMessage`, bounded like the error body, never the body's `trace` or `requestId`, and the entity lookup throws instead of reading the body as no match (#206). So does a submissions document or archive page whose JSON lacks what its readers index — `filings.recent`'s (or the page's) six columns `accessionNumber`, `filingDate`, `form`, `primaryDocument`, `primaryDocDescription`, `reportDate` as arrays, an array `filings.files`, array `tickers` and `exchanges` — checked in `getSubmissions` / `fetchArchivePage` before the cache write, so nothing is cached and the next call refetches (#186). Empty arrays pass; lengths and optional columns are not checked. When the last attempt gets no complete, readable answer — whatever the earlier ones got — the call fails as `ServiceUnavailable` with `data.reason: 'sec_unreachable'`, `retryable: true`, `url`, and a hint, declared beside `rate_limited` on the same tools; the message says which case (no response, a body that failed to read, a body that is not the JSON the request reads) and names host, attempts, and the transport code or the timeout, never the request URL, and the runtime's own text rides `cause` to the log only (#173, #181). When the last attempt answers 500, 502, 503, or 504 — whatever the earlier ones got — the call fails as `ServiceUnavailable`, a 504 too (it is SEC's gateway failing, as #173 codes this service's own header timeout; `data.status` keeps 504), with `data.reason: 'sec_unavailable'`, `retryable: true`, and a hint that SEC failed on its side and the same call can be retried in a minute, declared beside `sec_unreachable` on the same tools; its message reads like `sec_unreachable`'s (`SEC EDGAR (www.sec.gov) answered HTTP 503 on the last of 3 attempts.`, or `… on attempt 2 of 3; retries stopped at this call's 40 s budget for SEC failures.`), and the rest of `data` is the status mapping's: `url`, `status`, `statusText`, `statusCode`, and `retryAfter` when SEC sends `Retry-After` (#233), with SEC's body on the `cause` chain for the log (#244). `createApp({ teardown })` disposes the pacer through `disposeEdgarApiService()` (#116)
|
|
86
86
|
- **Parameter names:** one name per concept across tools — `company` (the entity a tool reads; on `get_institutional_holdings` that is the 13F filer), `filed_after` / `filed_before` (inclusive filing-date bounds), `forms`. Every tool carrying one of those keys declares `inputAliases` for the other spellings in use — `ticker`, `cik`, `ticker_or_cik` → `company`; `start_date`, `date_from` → `filed_after`; `end_date`, `date_to` → `filed_before`; `form_types` → `forms` — so a caller carrying a name from one tool to the next is not rejected (#115). An alias is declared only where it maps to exactly one key of that tool and its value shape fits: a singular `form_type` cannot fill the `forms` array, so it is left out rather than widening the schema. A tool whose only company input carries another name takes the same company-identifier spellings onto it — `company`, `ticker`, `cik`, `ticker_or_cik` → `issuer` on `find_holders` and `get_beneficial_owners`, and those plus `name` and `search` → `query` on `company_search` — since the key it moves into has no other reading there; the canonical names stay, because renaming them would break existing callers (#152). `fund` (a fund or series) and `companies` (an array) are not aliased. `company_search`'s `filing_limit` → `limit` on `search_filings`, `get_material_events`, and `get_beneficial_owners`, whose one count input counts filings; rewritten before validation, it meets `limit`'s own cap and bound in either `EDGAR_CLAMP_OVERSIZED_LIMITS` mode. A `limit` counting managers, transactions, positions, companies, or data points takes no such alias, and `company_search` takes no `limit` alias, since there it would read as a count of companies (#212). Every tool with the date pair accepts either bound alone. `search_filings` fills the missing one before routing, since EDGAR full-text search ignores a one-sided custom range: a lone `filed_after` runs through today (UTC), a lone `filed_before` starts at 2001-01-01, or at 1993-01-01 when it falls before 2001, and the full-text path discloses a filled window in `effectiveQuery` as `(filed <after> to <before>)` (#185)
|
|
87
87
|
- **User-Agent required:** `"AppName contact@email.com"` on every SEC request or IP gets blocked
|
|
88
88
|
- **CIK zero-padding:** the `data.sec.gov` APIs (submissions, companyfacts, companyconcept) require the 10-digit zero-padded CIK (`String(cik).padStart(10, '0')`). Archive paths under `www.sec.gov/Archives/edgar/data/` take it unpadded — SEC answers the padded path with a 301, and `fetch` follows it inside the same pacer slot, so every archive read would cost two requests. `filingArchiveUrl` (exported from `edgar-api-service.ts`) strips the zeros for all seven archive reads and for `get_filing`'s `filing_url` (#156)
|
|
89
89
|
- **ETF/mutual-fund tickers:** `loadTickerCache` fetches `company_tickers_mf.json` alongside `company_tickers.json` and merges fund symbols (VOO, SCHD, JEPI…) into `byTicker`. Fund CIKs are registrant trusts (1:many with series), so fund rows go into `byTicker` only — never `byCik`, whichever source they come from. Resolved fund matches carry `seriesId`/`classId` from the live MF file, the only source of either. With the mirror on and `EDGAR_MIRROR_FALLBACK_LIVE` on, the equity rows come from the live `company_tickers.json` every TTL as with no mirror, the live MF file is merged in, and the mirror's fund rows join behind it, so a fund symbol resolves when the live fund file lacks it or fails to load, and when the mirror predates MF ingestion (#43, #234). When `company_tickers.json` fails there — any failure, a rate-limit refusal included — `loadTickerBase` builds the index from all the mirror's rows, which stands for the full TTL with no retry window (it is complete, only stale), and logs one warning carrying `endpoint: 'company_tickers'`. Strict mirror-only (`FALLBACK_LIVE=false`) uses the mirror's rows alone (ticker→CIK, no series/class) and sends nothing; an empty ticker layer fails there as not synced. The mirror stores a fund symbol with an empty name — its schema has no series column — and `mirrorIndexRow` reads that empty name as the fund marker; a symbol claims `byTicker` in the order equity → live fund → mirror fund, so a live entry supersedes the mirror's bare row and keeps its series (#135). **The live fund slice has its own failure window:** a failed MF load (any HTTP failure, a malformed body, the block gate's refusal) is not cached for the ticker-cache TTL — `loadMfTickers` returns no rows and a `retryAt` `FUND_SLICE_RETRY_MS` (60 s) out, or the error's `retryAfter` when longer, so nothing is retried while the gate is closed. The first resolution after it refetches the file once, single-flight, onto the cached base (`reloadFundSlice`), which keeps its own load time: the equity index is not refetched and its TTL does not move. A per-resolution retry was rejected — against a persistent 5xx it adds three requests and ~3 s of backoff to every lookup (#119). Each failed load logs one warning through the framework's global `logger` (no request context to attach to) carrying `endpoint: 'company_tickers_mf'` (never the URL — framework log guidance keeps URLs out of log fields), the HTTP status or `malformed_body`, and the retry delay (#43).
|
|
90
|
-
- **Name and ticker resolution:** `resolveCik` walks numeric CIK → the listed-symbol lookup (`listedSymbol`), for 1–5 letters in any case and for anything typed in uppercase → for input typed in uppercase, the ticker-spelling readings (`readTickerSpelling`) → the name passes (exact → exact once folded → exact once initials join → prefix → substring over `allEntries`) → for input not typed in uppercase, the listed-symbol lookup the first step skipped. Four normalizations hang off that chain. The name passes' **exact** tiers also compare suffix-normalized forms (`normalizeCompanySuffix`): the terminal whitespace-delimited token only, a trailing `.`/`,` stripped as part of recognizing it, expanded to one of four canonical long forms — `corp`→`corporation`, `inc`→`incorporated`, `co`→`company`, `ltd`→`limited`. **The four buckets are never merged.** The registry carries distinct registrants differing only in which suffix they use (`TORO CO` 0000737758 vs `TORO CORP.` 0001941131, and the same shape on Blue Owl and Fluent), so a single "has a corporate suffix" marker would compare two companies equal. Only the terminal token is rewritten — the same words sit mid-name in titles ending in a different suffix (`American Water Works Company, Inc.`) — and a terminal token that merely contains one (`Ltd./ADR`) is not a suffix. Punctuation elsewhere in a name is the fold's (below). `llc`/`plc` and the `lp`/limited-partnership family get no bucket and must never fold into the `ltd` bucket (#107); they drop for a bare query (below) but never normalize into one of the four. The name passes **resolve within the best tier a current name reaches**: several CIKs there are the ambiguity, listed without the tiers below, so `Itron` resolves to ITRON, INC. instead of listing SOLITRON and POSITRON beside it. The exact tier also matches a registry name minus its terminal suffix and a comma before it (`stripCompanySuffix` over `DROPPABLE_SUFFIXES`: the four buckets plus `plc`, `llc`, `lp`, `nv`, `sa`, `ag`, and `se`, with or without periods), so `Apple` names `Apple Inc.` exactly. The wider set is deliberate: with the four buckets alone, `Rio Tinto` silently picked RIO TINTO LTD over RIO TINTO PLC; now both drop to an exact hit and tie. Only the registry side is stripped, so `Toro Co` never meets `TORO CORP.` and `Rio Tinto plc` never meets RIO TINTO LTD, and two suffix variants of one base name (`Blue Owl Capital`) tie. Current names (registry rows, which carry a ticker) choose the tier. A former name joins at that tier or better but never outranks one — otherwise `Travelers` resolves to Citigroup through its former name `travelers inc` — and decides alone only when no current name matches (`Facebook Inc`). Against the 2026-10-02 registry plus the former-names asset, 930 of 34,865 name queries move from ambiguous to resolved and no resolved CIK changes (#155). The **punctuation fold** (`foldNamePunctuation`, #210) deletes `,` `.` `'` `’` from the query and from every current and former name, then collapses each whitespace run to one space (#219), so `QXO Inc` meets `QXO, Inc.`, `Fluent Inc` meets `Fluent, Inc.`, `Jeffs Brands` the former name `jeffs' brands ltd`, and `Forgent Networks Inc` the former name `forgent networks inc`; a period is deleted, never spaced, so `U.S. Bancorp` meets `US BANCORP \DE\`. It is comparison-only — returned names and `suggestCompanies` never see it — and a helper of its own: `normalizeCompanySuffix` and `stripCompanySuffix` read the as-written strings, and the folded tiers run them again on the folded forms. Without the fold a weaker tier answered a punctuation-free spelling with another registrant (`BlackRock Inc` reached BLACKROCK INCOME TRUST, INC. by prefix, `Block Inc` H&R BLOCK INC by substring). Against the 2026-11-03 registry plus the former-names asset, no title queried as listed changes its answer and no title or former name changes CIK; six former names typed as listed now match several companies, the current registrant listed first, since a current title now matches them too (`energizer holdings inc` lists ENERGIZER HOLDINGS, INC. ahead of the former holder). The **initials join** (`joinSpacedInitials`, #219) turns each run of two or more one-letter words in a folded form into one word (`j m smucker co` → `jm smucker co`), so `JM Smucker` and `J.M. Smucker` meet `J M SMUCKER Co` and `WP Carey` meets `W. P. Carey Inc.`; it is comparison-only like the fold, and its tier runs the suffix helpers again on the joined forms. **No hit starts or ends inside a word** (#218): a prefix must end at a word boundary of the joined name and a substring must start at one in the name as written — a boundary is regex `\b`, a letter or digit on exactly one side — so `SY Bancorp, Inc.` no longer names Embassy Bancorp through `embassy`, `helix acquisition corp ii` no longer lists the later `Helix Acquisition Corp. III`, and `ticker:MRO` (a delisted symbol) no longer scopes to PermRock Royalty Trust. Tier order: exact as written, exact once folded, exact once initials join, prefix of the joined form, substring as written. Each tier ranks above the looser one after it, so a title typed as listed never ties a former name equal to it only once folded (`McGraw Hill, Inc.` stays alone beside S&P Global's former `mcgraw hill inc`), and `US Gold` names U.S. GOLD CORP. alone instead of tying McEwen's former `u s gold corp`, equal only once joined. Substring stays as written, so a query ending mid-word still reaches a name containing it as written (`Berkshire Hath`) but never one containing it only once folded: `Helix Acquisition Corp. III` folds to a name holding `helix acquisition corp ii`. A query with no letter or digit (`.`, `'`) is `no_match` instead of folding to a string that starts every name. Against the 2026-11-03 registry plus the former-names asset (#218, #219), no title queried as listed changes its answer; of the former names typed as listed, nine that matched several companies now resolve to their own CIK (`ace ltd` no longer lists MDA Space Ltd. beside Chubb), `total` keeps its CIK in a different list, and `u s gold corp` now matches several, U.S. GOLD CORP. first; 174 of the 178 joined or dotted spellings of the 63 names that space their initials resolve to their own CIK, against 15 before, the other four naming U.S. GOLD CORP.; and all 37 double-spaced former names resolve typed single-spaced, against 17 before. Only a query with no letter or digit loses its match, but a query cut short mid-word that the prefix tier answered alone can now list several companies (`baldw` lists Baldwin Insurance Group beside Matson, whose former name is `alexander & baldwin inc`). `\DE\`-style state tags, `&` `-` `/`, and a dotted word SEC splits in two (`AMAZON COM INC` for `Amazon.com`) stay out of scope. The **listed-symbol lookup** retries a dotted symbol with `.`→`-` on a miss — brokers and market data write `BRK.B` where `company_tickers.json` lists `BRK-B`, and that file carries exactly one dotted ticker, `ALDF.U` (a unit of Aldel Financial II, CIK 2031561), with no `ALDF-U` beside it, so the substitution cannot land on the wrong registrant (#110). It answers ahead of the name passes for 1–5 letters in any case and for anything typed in uppercase, so neither a reading nor the period fold ever takes a symbol the file lists; a symbol typed in mixed or lower case outside that shape (`brk.b`) meets it after the name passes, as before. **The ticker-spelling readings** (`listing-codes.ts`, #235) take input typed in uppercase that the lookup missed, before the name passes, whose period fold read `GS.K` as GSK plc, `SU.N` as SUN, and `CF.N` as CFN Enterprises: a US venue code after a listed symbol (`N` `O` `OQ` `A` `P` `K` `PK`; `UEC.N` → UEC, `BIP.PA.N` → BIP-PA); a preferred class run together, `<base>P<letter>` or `<base>PR<letter>` with a base of two or more letters, read as the listed `<base>-P<letter>` (`CFGPH` → CFG-PH, `PCGPRE` → PCG-PE; one-letter bases such as `C-PN` are left out, since `TPC` is Tutor Perini); and a root with no listing of its own, read as the company its hyphenated classes belong to (`GLOP` → GasLog Partners LP), or `ambiguous_company` when they belong to several. A non-US exchange code (`ME` `L` `HK` `T` `TO`: `7203.T`) is no match, and each tool's not-found message appends `nonUsListingNote`'s sentence saying EDGAR indexes SEC registrants by US ticker, name, or CIK. A match a reading produced carries `CikMatch.reading` (`UEC.N read as UEC (URANIUM ENERGY CORP)`; a root names its classes), which `search_filings` puts in `effectiveQuery`'s scope parenthetical (`(entity scope: CIK 0001334933, UEC.N read as UEC (URANIUM ENERGY CORP))`), `compare_companies` in one `caveats` line per input, and the other nine tools in a `resolvedAs` enrichment field, never `notice`, which each writes later and which is last-wins. Uppercase only, so `Ang` and `oak` keep their name-pass candidate lists; the accepted cost is a two-letter dotted initialism typed in uppercase without its closing period reading as a venue code — `B.P` as B (Barrick), `H.P` as H (Hyatt), `W.P` as W (Wayfair), `J.P` as J (Jacobs) — while `B.P.`, `H.P.`, and `b.p` still reach BP and HP. `search_filings`' `ticker:` token gets all of it through `resolveCik` with no change of its own. **No consumer reads the first of several matches** (#223): `company_search`, `get_material_events`, `get_financials`, `get_snapshot`, `get_insider_transactions`, and `search_filings`' `ticker:` token throw `ambiguous_company` (`ValidationError`, one reason and one wording across the six, #228; `data.matches` of `cik`/`name`/`ticker`, the first 10, also listed in the message, and `data.total_matches`, the full count) before any SEC read; `find_holders` and `get_beneficial_owners` `ambiguous_issuer`, `get_institutional_holdings` `ambiguous_entity`, `get_fund_holdings` `ambiguous_fund`, and `compare_companies` reports a per-company `failed[]` reason `ambiguous`. `search_filings`' `cik:` token resolves a zero-padded CIK, which never matches several. `resolveCik` returns every candidate of its best tier, uncut, and `ambiguousMatches` (`src/mcp-server/tools/ambiguous-matches.ts`) is the one cut every ambiguity error shares: the first 10 in resolution order, `data.total_matches` beside them, and, when the list is partial, a message ending `Showing 10 of 66 matches; for one not listed, retry with a fuller name, its ticker, or its CIK.` — `retry with its ticker or CIK.` for `search_filings`' `ticker:` token, which takes no spaces and so no fuller name. Its consumers are the six `ambiguous_company` tools, the four role-specific tools (each keeping its own reason, item wording, and hint), and `compare_companies`' ambiguous `failed_companies[].message`, which takes the list and the sentence and no field. `get_institutional_holdings`' fallback for a name the registry misses, EDGAR entity search (`resolveEntityByName`, `keysTyped=`), returns SEC's first 10 hits beside SEC's `hits.total`, which becomes `data.total_matches` — `of at least 10,000`, with `data.total_matches_is_lower_bound: true`, when its `relation` is `gte`, a floor (#230). When no `compare_companies` input resolves, `no_companies_resolved`'s message repeats each input's `failed_companies[].message`, so `content[]` names the same reasons and candidates as `data.failed_companies` (#231). The 5-candidate cut it replaces hid 61 of `American`'s 66 candidates, American Airlines among them, behind a list that read as complete (#229).
|
|
90
|
+
- **Name and ticker resolution:** `resolveCik` walks numeric CIK → the listed-symbol lookup (`listedSymbol`), for 1–5 letters in any case and for anything typed in uppercase; its answer never changes, but a symbol an earlier, different company held carries a `reading` naming that holder (#237) → for input typed in uppercase, the ticker-spelling readings (`readTickerSpelling`) → the name passes (exact → exact once folded → exact once initials join → prefix → substring over `allEntries`), weighed for input typed in uppercase against a former ticker (`readFormerTicker`, below) → only when no tier matches and the query has two or more words, the word-order tier → for input not typed in uppercase, the listed-symbol lookup the first step skipped, then a former ticker. An uppercase former ticker answers ahead of the names unless a current name is the input exactly (`CHUBB` stays Chubb Ltd, not CommerceHub), or its holder is listed no more and the names find one company (`DINE` stays Dine Brands, not Rewards Network): it reads `BK` as BNY over BK Technologies Corp, whose name only starts with it, and settles `STR`, which starts many names. Lowercase input keeps the name passes first (`bk` keeps its name-pass answer; `amrk` reaches Gold.com). **The word-order tier (#236)** compares a query's words as a set: the key is the joined form (initials joined) with its terminal suffix normalized, words sorted, and a current or former name meets it under the same key, or under its key with the terminal suffix dropped, so `Charles Schwab` names SCHWAB CHARLES CORP and `JB Hunt Transport Services` HUNT J B TRANSPORT SERVICES INC. Names of one word never reach it, the query's own suffix is never dropped, current names list before former ones, and several CIKs list as the ambiguity. It runs only when every name tier misses, so it changes no answer that resolves without it, and it lives in `resolveCik` because EDGAR's entity index (below) answers `Charles Schwab` with a 2008–2010 Reg D filer's exact hit, and index hits come after every local tier. **`company_search` alone then tries the network** when `resolveCik` returns no match: EDGAR's entity index (`resolveEntityByName`, `keysTyped=`, SEC's first 10 hits), then one quoted full-text search of 10-K subsidiaries exhibits (`findSubsidiaryParents`). SEC's trailing ticker list is split from each index name (`SCHWAB CHARLES CORP (SCHW, SCHW-PJ, SCHW-PD)` → name `SCHWAB CHARLES CORP`, ticker `SCHW`), and the hits are ranked on name tiers 0–4: one CIK at an exact tier (0–2) resolves, with a `resolvedAs` reading; several at the best tier fail `ambiguous_company`, with SEC's `hits.total` as `total_matches` when SEC returned only part of its hits (#230); a lone hit at the prefix or substring tier is a near match (Near-match suggestions). Only when no index hit reaches a tier does the exhibits search run: the filers of an EX-21 hit go in the `no_match` message and `data.parents`, ticker-file filers first, then the newest exhibit, and any other document's hit is never named, since a lender's schedule of investments or a competitor's narrative says nothing about ownership; with no EX-21 hit the message points to `secedgar_search_filings` with the quoted name, its JSON arguments passed as an error `literals` value so `content[]` prints them as code, unescaped. A non-US listing code (`7203.T`), a query with no letter or digit, and any query a local pass answers send no request, and strict mirror mode runs both steps, since EFTS is not mirrored. **An index failure fails the call with its reason** (`efts_degraded_response`, `sec_unavailable`, `rate_limited`), never `no_match`, because the server then cannot say whether the company exists; **an exhibits-search failure keeps `no_match`** (SEC unavailable or a rate-limit refusal) and says that search did not run, since the answer is already `no_match` and no request follows it. The caller's cancel rethrows from either step. Four normalizations hang off the name passes. The name passes' **exact** tiers also compare suffix-normalized forms (`normalizeCompanySuffix`): the terminal whitespace-delimited token only, a trailing `.`/`,` stripped as part of recognizing it, expanded to one of four canonical long forms — `corp`→`corporation`, `inc`→`incorporated`, `co`→`company`, `ltd`→`limited`. **The four buckets are never merged.** The registry carries distinct registrants differing only in which suffix they use (`TORO CO` 0000737758 vs `TORO CORP.` 0001941131, and the same shape on Blue Owl and Fluent), so a single "has a corporate suffix" marker would compare two companies equal. Only the terminal token is rewritten — the same words sit mid-name in titles ending in a different suffix (`American Water Works Company, Inc.`) — and a terminal token that merely contains one (`Ltd./ADR`) is not a suffix. Punctuation elsewhere in a name is the fold's (below). `llc`/`plc` and the `lp`/limited-partnership family get no bucket and must never fold into the `ltd` bucket (#107); they drop for a bare query (below) but never normalize into one of the four. The name passes **resolve within the best tier a current name reaches**: several CIKs there are the ambiguity, listed without the tiers below, so `Itron` resolves to ITRON, INC. instead of listing SOLITRON and POSITRON beside it. The exact tier also matches a registry name minus its terminal suffix and a comma before it (`stripCompanySuffix` over `DROPPABLE_SUFFIXES`: the four buckets plus `plc`, `llc`, `lp`, `nv`, `sa`, `ag`, and `se`, with or without periods), so `Apple` names `Apple Inc.` exactly. The wider set is deliberate: with the four buckets alone, `Rio Tinto` silently picked RIO TINTO LTD over RIO TINTO PLC; now both drop to an exact hit and tie. Only the registry side is stripped, so `Toro Co` never meets `TORO CORP.` and `Rio Tinto plc` never meets RIO TINTO LTD, and two suffix variants of one base name (`Blue Owl Capital`) tie. Current names (registry rows, which carry a ticker) choose the tier. A former name joins at that tier or better but never outranks one — otherwise `Travelers` resolves to Citigroup through its former name `travelers inc` — and decides alone only when no current name matches (`Facebook Inc`). Against the 2026-10-02 registry plus the former-names asset, 930 of 34,865 name queries move from ambiguous to resolved and no resolved CIK changes (#155). The **punctuation fold** (`foldNamePunctuation`, #210) deletes `,` `.` `'` `’` from the query and from every current and former name, then collapses each whitespace run to one space (#219), so `QXO Inc` meets `QXO, Inc.`, `Fluent Inc` meets `Fluent, Inc.`, `Jeffs Brands` the former name `jeffs' brands ltd`, and `Forgent Networks Inc` the former name `forgent networks inc`; a period is deleted, never spaced, so `U.S. Bancorp` meets `US BANCORP \DE\`. It is comparison-only — returned names and `suggestCompanies` never see it — and a helper of its own: `normalizeCompanySuffix` and `stripCompanySuffix` read the as-written strings, and the folded tiers run them again on the folded forms. Without the fold a weaker tier answered a punctuation-free spelling with another registrant (`BlackRock Inc` reached BLACKROCK INCOME TRUST, INC. by prefix, `Block Inc` H&R BLOCK INC by substring). Against the 2026-11-03 registry plus the former-names asset, no title queried as listed changes its answer and no title or former name changes CIK; six former names typed as listed now match several companies, the current registrant listed first, since a current title now matches them too (`energizer holdings inc` lists ENERGIZER HOLDINGS, INC. ahead of the former holder). The **initials join** (`joinSpacedInitials`, #219) turns each run of two or more one-letter words in a folded form into one word (`j m smucker co` → `jm smucker co`), so `JM Smucker` and `J.M. Smucker` meet `J M SMUCKER Co` and `WP Carey` meets `W. P. Carey Inc.`; it is comparison-only like the fold, and its tier runs the suffix helpers again on the joined forms. **No hit starts or ends inside a word** (#218): a prefix must end at a word boundary of the joined name and a substring must start at one in the name as written — a boundary is regex `\b`, a letter or digit on exactly one side — so `SY Bancorp, Inc.` no longer names Embassy Bancorp through `embassy`, `helix acquisition corp ii` no longer lists the later `Helix Acquisition Corp. III`, and `ticker:MRO` (a delisted symbol) no longer scopes to PermRock Royalty Trust. Tier order: exact as written, exact once folded, exact once initials join, prefix of the joined form, substring as written. Each tier ranks above the looser one after it, so a title typed as listed never ties a former name equal to it only once folded (`McGraw Hill, Inc.` stays alone beside S&P Global's former `mcgraw hill inc`), and `US Gold` names U.S. GOLD CORP. alone instead of tying McEwen's former `u s gold corp`, equal only once joined. Substring stays as written, so a query ending mid-word still reaches a name containing it as written (`Berkshire Hath`) but never one containing it only once folded: `Helix Acquisition Corp. III` folds to a name holding `helix acquisition corp ii`. A query with no letter or digit (`.`, `'`) is `no_match` instead of folding to a string that starts every name. Against the 2026-11-03 registry plus the former-names asset (#218, #219), no title queried as listed changes its answer; of the former names typed as listed, nine that matched several companies now resolve to their own CIK (`ace ltd` no longer lists MDA Space Ltd. beside Chubb), `total` keeps its CIK in a different list, and `u s gold corp` now matches several, U.S. GOLD CORP. first; 174 of the 178 joined or dotted spellings of the 63 names that space their initials resolve to their own CIK, against 15 before, the other four naming U.S. GOLD CORP.; and all 37 double-spaced former names resolve typed single-spaced, against 17 before. Only a query with no letter or digit loses its match, but a query cut short mid-word that the prefix tier answered alone can now list several companies (`baldw` lists Baldwin Insurance Group beside Matson, whose former name is `alexander & baldwin inc`). `\DE\`-style state tags, `&` `-` `/`, and a dotted word SEC splits in two (`AMAZON COM INC` for `Amazon.com`) stay out of scope. The **listed-symbol lookup** retries a dotted symbol with `.`→`-` on a miss — brokers and market data write `BRK.B` where `company_tickers.json` lists `BRK-B`, and that file carries exactly one dotted ticker, `ALDF.U` (a unit of Aldel Financial II, CIK 2031561), with no `ALDF-U` beside it, so the substitution cannot land on the wrong registrant (#110). It answers ahead of the name passes for 1–5 letters in any case and for anything typed in uppercase, so neither a reading nor the period fold ever takes a symbol the file lists; a symbol typed in mixed or lower case outside that shape (`brk.b`) meets it after the name passes, as before. **The ticker-spelling readings** (`listing-codes.ts`, #235) take input typed in uppercase that the lookup missed, before the name passes, whose period fold read `GS.K` as GSK plc, `SU.N` as SUN, and `CF.N` as CFN Enterprises: a US venue code after a listed symbol (`N` `O` `OQ` `A` `P` `K` `PK`; `UEC.N` → UEC, `BIP.PA.N` → BIP-PA); a preferred class run together, `<base>P<letter>` or `<base>PR<letter>` with a base of two or more letters, read as the listed `<base>-P<letter>` (`CFGPH` → CFG-PH, `PCGPRE` → PCG-PE; one-letter bases such as `C-PN` are left out, since `TPC` is Tutor Perini); and a root with no listing of its own, read as the company its hyphenated classes belong to (`GLOP` → GasLog Partners LP), or `ambiguous_company` when they belong to several. A non-US exchange code (`ME` `L` `HK` `T` `TO`: `7203.T`) is no match, and each tool's not-found message appends `nonUsListingNote`'s sentence saying EDGAR indexes SEC registrants by US ticker, name, or CIK. A match a reading produced carries `CikMatch.reading` (`UEC.N read as UEC (URANIUM ENERGY CORP)`; a root names its classes), which `search_filings` puts in `effectiveQuery`'s scope parenthetical (`(entity scope: CIK 0001334933, UEC.N read as UEC (URANIUM ENERGY CORP))`), `compare_companies` in one `caveats` line per input, and the other nine tools in a `resolvedAs` enrichment field, never `notice`, which each writes later and which is last-wins. Uppercase only, so `Ang` and `oak` keep their name-pass candidate lists; the accepted cost is a two-letter dotted initialism typed in uppercase without its closing period reading as a venue code — `B.P` as B (Barrick), `H.P` as H (Hyatt), `W.P` as W (Wayfair), `J.P` as J (Jacobs) — while `B.P.`, `H.P.`, and `b.p` still reach BP and HP. `search_filings`' `ticker:` token gets all of it through `resolveCik` with no change of its own. **No consumer reads the first of several matches** (#223): `company_search`, `get_material_events`, `get_financials`, `get_snapshot`, `get_insider_transactions`, and `search_filings`' `ticker:` token throw `ambiguous_company` (`ValidationError`, one reason and one wording across the six, #228; `data.matches` of `cik`/`name`/`ticker`, the first 10, also listed in the message, and `data.total_matches`, the full count) before any SEC read; `find_holders` and `get_beneficial_owners` `ambiguous_issuer`, `get_institutional_holdings` `ambiguous_entity`, `get_fund_holdings` `ambiguous_fund`, and `compare_companies` reports a per-company `failed[]` reason `ambiguous`. `search_filings`' `cik:` token resolves a zero-padded CIK, which never matches several. `resolveCik` returns every candidate of its best tier, uncut, and `ambiguousMatches` (`src/mcp-server/tools/ambiguous-matches.ts`) is the one cut every ambiguity error shares: the first 10 in resolution order, `data.total_matches` beside them, and, when the list is partial, a message ending `Showing 10 of 66 matches; for one not listed, retry with a fuller name, its ticker, or its CIK.` — `retry with its ticker or CIK.` for `search_filings`' `ticker:` token, which takes no spaces and so no fuller name. Its consumers are the six `ambiguous_company` tools, the four role-specific tools (each keeping its own reason, item wording, and hint), and `compare_companies`' ambiguous `failed_companies[].message`, which takes the list and the sentence and no field. `get_institutional_holdings`' fallback for a name the registry misses, EDGAR entity search (`resolveEntityByName`, `keysTyped=`), returns SEC's first 10 hits beside SEC's `hits.total`, which becomes `data.total_matches` — `of at least 10,000`, with `data.total_matches_is_lower_bound: true`, when its `relation` is `gte`, a floor (#230). When no `compare_companies` input resolves, `no_companies_resolved`'s message repeats each input's `failed_companies[].message`, so `content[]` names the same reasons and candidates as `data.failed_companies` (#231). The 5-candidate cut it replaces hid 61 of `American`'s 66 candidates, American Airlines among them, behind a list that read as complete (#229).
|
|
91
91
|
- **Former-name resolution:** `src/services/edgar/data/former-names.json` is a committed asset (generated offline via `bun run gen:former-names`) containing `[lowercasedFormerName, zeroPaddedCIK]` tuples. `buildTickerCache` folds them into `allEntries` for name search and the trigram pass. Regenerate on demand after major M&A waves — former names are immutable, so the file rarely needs updating.
|
|
92
|
-
- **
|
|
92
|
+
- **Former-ticker resolution (#237):** `src/services/edgar/data/former-tickers.json` is a committed asset (generated offline via `bun run gen:former-tickers`) of `[TICKER, zeroPaddedCIK, "YYYY-MM", title]` tuples: every symbol → CIK pair a monthly Wayback Machine capture of `company_tickers.json` lists and the live file at generation does not. The month is the latest capture listing the pair — a **capture date, not a delisting date** — and the title is the holder's in that capture. The generator reads Wayback's CDX index once, then each capture sequentially and paced, decodes gzip-encoded bodies, and skips one that does not parse; a capture repeating any digest but the newest one seen so far is a **stale copy** SEC's CDN served again (2019-08 repeats 2017-08's file byte for byte), so it adds no month. Its downloads are cached, so a rerun after a stop resumes. `buildTickerCache` indexes the rows beside `allEntries` (`buildFormerTickerIndex`), and the lookup sends no SEC request, strict mirror mode included. A symbol several companies held resolves to the **most recent holder** rather than failing as ambiguous, so no call that resolves today starts failing; its `reading` names that company (its current name and ticker when listed, else its title as last listed), the capture month, and any earlier holders. A symbol the file still lists answers as listed, and when an earlier, different company held it the `reading` names that holder, its CIK, and the month (`XOM` stays ExxonMobil Holdings Corp and names EXXON MOBIL CORP). A symbol that leaves the file after the asset was generated misses until the next `bun run gen:former-tickers`; run it on demand, as with former names.
|
|
93
|
+
- **Near-match suggestions:** `suggestCompanies(query, allEntries)` runs a Dice-coefficient trigram pass on the zero-hit search path, returning up to 3 candidates above a threshold. Each entry is scored on its **name and its ticker**, keeping the higher of the two — one ranked, deduped, top-N list rather than two disjoint ones, so a strong ticker match can outrank a weak name match and vice versa, and a ticker-shaped miss gets help instead of a bare `no_match` (#111). An entry missing either field is simply not scored on it: former-name entries carry a name and no ticker, and MF rows carry neither a name nor a place in `allEntries`, so fund tickers stay structurally unreachable here regardless of what the scorer does. Suggestions appear in the `no_match` error `data.suggestions` and in the error message. Never auto-resolves. A lone EDGAR entity-index hit that reaches only the prefix or substring name tier leads `data.suggestions`, ahead of the trigram candidates (#236). Only the throw that attaches suggestions or parents names the field in its hint (`company_search` passes its own `recovery.hint`: one sentence per field attached, then the contract text); the contract's `no_match` recovery never mentions it, since a zero-hit miss with no near match and the bare-CIK 404 carry no `suggestions` (#153).
|
|
93
94
|
- **XBRL friendly names:** `concept-map.ts` maps `"revenue"` → real XBRL tags; handles historical tag changes (ASC 606), including both assessed-tax variants — a filer presenting revenue gross of excise/sales tax reports only `RevenueFromContractWithCustomerIncludingAssessedTax`, and without it the walk fell through to tags SEC retired in 2018 (#98). The Including variant sits BEHIND `Revenues`, not ahead of it — the two disagree for filers that tag gross sales and net-of-excise sales under separate elements, so promoting it over `Revenues` swaps the definition partway back through the history and prints a step change that is a tag switch, not a business fact; behind `Revenues` it only fills frames no current tag covers. The same precedent places successor tags: `capex` walks `PaymentsToAcquireProductiveAssets` behind the PP&E-only tag (it also counts software and intangibles) and `interest_expense` walks `InterestExpenseNonoperating` behind both older tags, so NVIDIA, Amazon, Visa, and Microsoft reach current values and no frame the older tags cover changes (#125); the banks' `InterestExpenseOperating` (JPMorgan, Bank of America, and Wells Fargo report interest expense only under it from 2024) goes behind that, since it matches `InterestExpense` for 33 of 37 CY2025Q2 filers reporting both but `InterestExpenseNonoperating` for 0 of 4 (#147). SEC serves both successors with no label, so the line falls back to the concept's label. A different-definition tag still goes in `relatedTags`, never `tags` — `ppe_net`'s finance-lease-inclusive total is the primary line for Alphabet, Meta, and Tesla (#36, #130). `ifrsTags` covers every concept with an IFRS element confirmed present in a live 20-F filer's companyfacts; `notes_payable` is deliberately unmapped (IFRS presents borrowings as one caption, with no notes/debt split) and `shares_outstanding` is `dei`. Never add an `ifrsTags` entry from the taxonomy alone — an element existing is not evidence filers tag it (#99). `ifrsTags` order is semantic the same way `tags` is: index 0 is the counterpart of the us-gaap index-0 tag, so the same concept answers the same question under either taxonomy (`accounts_receivable` leads with the trade-only caption, not the combined trade-and-other one; `share_repurchases` with the financing outflow, not the treasury-only line a share-cancelling filer tags zero). Verify a candidate order against filers that report BOTH tags — presence alone does not settle which one leads. One concept has no right order: IFRS filers split between the employee-scheme share-based-payment element and the IFRS 2.51(a) expense total, and the two invert between filers (SAP's total is its real line with the employee element a two-period fringe; Sanofi is the exact opposite), so `stock_based_compensation` carries `ifrsTagSelection: 'coverage'` and picks per filer by which tag covers more standard periods (#101). It is the only concept that does, and the flag is scoped to `ifrsTags` on purpose — its us-gaap pair IS a ladder, since `AllocatedShareBasedCompensationExpense` is the disaggregated line and out-covers the total for Alphabet, IBM, Tesla, and P&G.
|
|
94
95
|
- **`fetch_frames` reads one tag:** a friendly name sends one frames request, for its first tag; the rest come back in `unqueried_tags` on a success and on `no_data`, whose hint says to query each. Revenue's first tag has no annual frame before CY2014, so an older revenue screen names one of the listed tags directly. The hint names no start year: frame coverage is per tag (#207).
|
|
95
96
|
- **`compare_companies` lists:** `companies` takes the first 10 inputs as given and `concepts` the first 8 distinct known concepts (merged spellings count once, unknown names none); the rest come back in `deferred_companies` / `deferred_concepts` behind `EDGAR_CLAMP_OVERSIZED_LIMITS`, through `batchClamp` in `limit-clamp.ts`, and the 10 x 8 bound keeps the inline-matrix cell ceiling valid (#201). The notice names the re-call — three when both lists defer: deferred companies with the 8 compared concepts, the 10 companies read with deferred concepts, and the two deferred lists together — since a re-call pairing one deferred list with the other full input list passes the other cap and repeats cells another re-call reads; a lone deferred company is paired with one of the 10 in its two re-calls, and that company leaves the second. An input resolving to a CIK an earlier input already holds is read once, under the earlier input, with a caveat like the concept merge's; it still takes a slot (#217).
|
|
@@ -207,7 +208,7 @@ throw notFound('Item not found', { itemId }); // explicit code
|
|
|
207
208
|
throw new Error('Item not found'); // auto-classified → NotFound
|
|
208
209
|
```
|
|
209
210
|
|
|
210
|
-
**HTTP responses.** `httpErrorFromResponse(response, { service, data })` from `/utils` maps the full status table (401/403/408/422/429/5xx) and captures body + `Retry-After`. Used in `EdgarApiService` with `captureBody: false`: the framework's capture awaits each read with no stall bound or signal, so the service reads the 500-byte diagnostic itself through `readBody` and passes it on `data` (#
|
|
211
|
+
**HTTP responses.** `httpErrorFromResponse(response, { service, data })` from `/utils` maps the full status table (401/403/408/422/429/5xx) and captures body + `Retry-After`. Used in `EdgarApiService` with `captureBody: false`: the framework's capture awaits each read with no stall bound or signal, so the service reads the 500-byte diagnostic itself through `readBody` (#202) and passes it as the error's `cause`, never on `data`: the framework keeps off the wire only a body its own capture read, so a body on `data` reaches the caller as given, while the call's failure log record writes each cause's `data` under its `requestId` (#244).
|
|
211
212
|
|
|
212
213
|
See framework CLAUDE.md and the `api-errors` skill for the full reference.
|
|
213
214
|
|
|
@@ -226,6 +227,8 @@ src/
|
|
|
226
227
|
call-scope.ts # Per-call cancel signal + SEC failure budget (#179)
|
|
227
228
|
submissions-archive.ts # Shared archive-page walk (page cap, order, early stop)
|
|
228
229
|
filing-headers.ts # SEC submission-header parsers
|
|
230
|
+
listing-codes.ts # Ticker-spelling readings (venue codes, preferred classes, class roots) + non-US listing note
|
|
231
|
+
former-tickers.ts # Former-ticker index and readings (#237)
|
|
229
232
|
concept-map.ts # Friendly name → XBRL tag mapping + taxonomy/tag resolution
|
|
230
233
|
concept-series.ts # Shared frame dedup, tag selection, staleness caveats
|
|
231
234
|
trigram-similarity.ts # Dice trigram scorer for near-match suggestions
|
|
@@ -237,6 +240,9 @@ src/
|
|
|
237
240
|
nport-parser.ts # NPORT-P header (series routing) + full report
|
|
238
241
|
filing-to-text.ts # HTML / SGML submission → plain text
|
|
239
242
|
types.ts # Domain types
|
|
243
|
+
data/
|
|
244
|
+
former-names.json # Committed asset: former registrant names (bun run gen:former-names)
|
|
245
|
+
former-tickers.json # Committed asset: former ticker → CIK pairs from Wayback captures (bun run gen:former-tickers)
|
|
240
246
|
mirror/ # Opt-in local SQLite mirror (framework MirrorService)
|
|
241
247
|
edgar-mirror.ts # two stores + ready-gated read helpers
|
|
242
248
|
tickers-sync.ts # company_tickers.json ingester
|
|
@@ -253,7 +259,7 @@ src/
|
|
|
253
259
|
tools/format-usd.ts # USD amounts scaled by magnitude (T/B/M/K, sign before the $) and every-digit grouping for content[] (#222)
|
|
254
260
|
tools/form-filter.ts # `forms` normalization (trim, uppercase, drop blanks) shared by search_filings and company_search (#194)
|
|
255
261
|
tools/limit-clamp.ts # Over-cap numeric inputs served at the cap (#197) and ID lists answered to the cap (#201), behind EDGAR_CLAMP_OVERSIZED_LIMITS
|
|
256
|
-
tools/resolved-as.ts # The `resolvedAs` enrichment field of the company-resolving tools (how an unlisted ticker spelling
|
|
262
|
+
tools/resolved-as.ts # The `resolvedAs` enrichment field of the company-resolving tools (how an input was read: an unlisted ticker spelling #235, a former ticker or earlier holder #237, an entity-index match #236)
|
|
257
263
|
tools/sec-upstream-errors.ts # The `rate_limited`, `sec_unreachable`, and `sec_unavailable` error-contract entries every SEC-reaching tool spreads into its `errors`
|
|
258
264
|
tools/definitions/
|
|
259
265
|
index.ts # buildToolDefinitions() — the createApp() tool list, drop tool gated via disabledTool(), clamped tools built from clampOversizedLimits
|
|
@@ -279,6 +285,9 @@ src/
|
|
|
279
285
|
filing-types.resource.ts
|
|
280
286
|
prompts/definitions/
|
|
281
287
|
company-analysis.prompt.ts
|
|
288
|
+
scripts/
|
|
289
|
+
gen-former-names.ts # Offline generator for data/former-names.json (never part of the build)
|
|
290
|
+
gen-former-tickers.ts # Offline generator for data/former-tickers.json: Wayback captures of company_tickers.json
|
|
282
291
|
```
|
|
283
292
|
|
|
284
293
|
---
|
package/CLAUDE.md
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
# Agent Protocol
|
|
2
2
|
|
|
3
3
|
**Server:** secedgar-mcp-server
|
|
4
|
-
**Version:** 0.19.
|
|
4
|
+
**Version:** 0.19.1
|
|
5
5
|
**Framework:** [@cyanheads/mcp-ts-core](https://www.npmjs.com/package/@cyanheads/mcp-ts-core) `^0.13.22`
|
|
6
6
|
**Engines:** Bun ≥1.4.4, Node ≥24.0.0
|
|
7
7
|
**MCP SDK:** `@modelcontextprotocol/server` ^2.4.0
|
|
@@ -82,14 +82,15 @@ Tailor suggestions to what's actually missing or stale — don't recite the full
|
|
|
82
82
|
|
|
83
83
|
## Domain Notes
|
|
84
84
|
|
|
85
|
-
- **Rate limit:** 10 req/s per IP. Every SEC request goes through one process-wide `createPacer` queue in `EdgarApiService` that spaces request *starts* `1000 / EDGAR_RATE_LIMIT_RPS` ms apart, with no concurrency cap and no wait budget — an ordinary burst drains at the configured rate and is never shed, and this server's own traffic can never exceed it, so `rateLimitRps` stays at 10 and headroom for a co-tenant on the outbound IP is the operator's call via `EDGAR_RATE_LIMIT_RPS`. A 429 is **not** retried: SEC holds the block until the request rate has stayed under the threshold for ten minutes and every request sent meanwhile restarts that clock, so the ~3s retry budget (`MAX_RETRIES` 3 × `BASE_BACKOFF_MS` 1000, exponential) cannot outlast it (#112). Instead a 429 closes the service's **block gate** for `EDGAR_RATE_LIMIT_COOLDOWN_SECONDS` (default 600). While it is closed nothing is sent: a call fails locally as `RateLimited` with `retryAfter` set to the whole seconds remaining (never below 1), and the gate is re-read at dispatch, so a call already queued in the pacer when the 429 landed — or a 5xx, no-response, or body-failure retry sleeping through its backoff — is refused too. The first call after the cool-down is sent alone as a probe while every other call waits on it: any HTTP answer but a 429 reopens normal pacing, a probe 429 closes the gate for the full cool-down again, and a probe that gets no HTTP answer (a network error, or no headers within the per-attempt cap) proves nothing, so the next call probes in its place — and every call that waited on it counts that probe as one of its own no-response attempts, so calls queued behind a silent SEC each settle within their own three-attempt ladder instead of probing in turn, 15 s apiece (#173). **The gate lives in the service, not in the pacer's `cooldown` option** — that gate holds queued calls until it reopens and then releases them all at the pacing rate, so it can neither refuse locally nor keep the reopening to one request. The upstream 429 and the local refusal carry one `data.reason: 'rate_limited'`, declared (`thrownBy: 'service'`, `retryable: true`) on every tool that reaches SEC, plus `data.retryable: true` — `ctx.fail` copies a contract entry's `retryable` onto `data`, a service throw does not, so both throw sites set it themselves (#122) — and one recovery hint naming SEC's ten-minute window and the seconds to wait; SEC's HTML block page stays out of the payload: the 429's body is cancelled unread (#188). Reads the local mirror can answer keep answering during a block: their live reads (the ticker file, a filer's submissions or point read, an open period's frame) are refused locally like any other, and the mirror answers in their place (Local mirror below). 500/502/503/504 still retry with the backoff, and so does an attempt that gets no HTTP response at all — a `fetch` rejection (Bun sets the transport code on the error itself, Node's undici on its `cause`) or no response headers within `ATTEMPT_HEADERS_TIMEOUT_MS` (15 s from dispatch; pacer queue time and the body read are outside it) (#173). Each tool call's `CallScope` carries a failure budget, `CALL_FAILURE_BUDGET_MS` (40 s, `call-scope.ts`): the time SEC spends failing the call — unanswered-attempt and 5xx waits, backoff, body-idle time — is charged to it and healthy progress never is, attempt and body-idle waits are clamped to what is left, a backoff is slept only while the budget outlasts it, and once it is spent no further attempt or backoff starts and the request fails as `sec_unreachable` or, after a 5xx, `sec_unavailable`, so a call against an unresponsive SEC settles inside the MCP client's 60 s default; the caller's `ctx.signal` reaches every pacer wait, fetch, body read, and backoff, and a cancel rethrows untouched, never retried or counted as an SEC failure (#179). Every body is read inside that ladder, in `rawFetch`'s one body reader (`readBody`), so a 2xx whose body fails after its headers — the connection breaks off, invalid chunk framing or compression, or no bytes for `BODY_IDLE_TIMEOUT_MS` (15 s between reads, never across the whole body, so a body still arriving is never cut) — retries the same way; a probe whose headers arrive has already reopened the gate, and only its own call retries the body. The error body is read there too: a non-retryable status's or a last-attempt 5xx's body is captured
|
|
85
|
+
- **Rate limit:** 10 req/s per IP. Every SEC request goes through one process-wide `createPacer` queue in `EdgarApiService` that spaces request *starts* `1000 / EDGAR_RATE_LIMIT_RPS` ms apart, with no concurrency cap and no wait budget — an ordinary burst drains at the configured rate and is never shed, and this server's own traffic can never exceed it, so `rateLimitRps` stays at 10 and headroom for a co-tenant on the outbound IP is the operator's call via `EDGAR_RATE_LIMIT_RPS`. A 429 is **not** retried: SEC holds the block until the request rate has stayed under the threshold for ten minutes and every request sent meanwhile restarts that clock, so the ~3s retry budget (`MAX_RETRIES` 3 × `BASE_BACKOFF_MS` 1000, exponential) cannot outlast it (#112). Instead a 429 closes the service's **block gate** for `EDGAR_RATE_LIMIT_COOLDOWN_SECONDS` (default 600). While it is closed nothing is sent: a call fails locally as `RateLimited` with `retryAfter` set to the whole seconds remaining (never below 1), and the gate is re-read at dispatch, so a call already queued in the pacer when the 429 landed — or a 5xx, no-response, or body-failure retry sleeping through its backoff — is refused too. The first call after the cool-down is sent alone as a probe while every other call waits on it: any HTTP answer but a 429 reopens normal pacing, a probe 429 closes the gate for the full cool-down again, and a probe that gets no HTTP answer (a network error, or no headers within the per-attempt cap) proves nothing, so the next call probes in its place — and every call that waited on it counts that probe as one of its own no-response attempts, so calls queued behind a silent SEC each settle within their own three-attempt ladder instead of probing in turn, 15 s apiece (#173). **The gate lives in the service, not in the pacer's `cooldown` option** — that gate holds queued calls until it reopens and then releases them all at the pacing rate, so it can neither refuse locally nor keep the reopening to one request. The upstream 429 and the local refusal carry one `data.reason: 'rate_limited'`, declared (`thrownBy: 'service'`, `retryable: true`) on every tool that reaches SEC, plus `data.retryable: true` — `ctx.fail` copies a contract entry's `retryable` onto `data`, a service throw does not, so both throw sites set it themselves (#122) — and one recovery hint naming SEC's ten-minute window and the seconds to wait; SEC's HTML block page stays out of the payload: the 429's body is cancelled unread (#188). Reads the local mirror can answer keep answering during a block: their live reads (the ticker file, a filer's submissions or point read, an open period's frame) are refused locally like any other, and the mirror answers in their place (Local mirror below). 500/502/503/504 still retry with the backoff, and so does an attempt that gets no HTTP response at all — a `fetch` rejection (Bun sets the transport code on the error itself, Node's undici on its `cause`) or no response headers within `ATTEMPT_HEADERS_TIMEOUT_MS` (15 s from dispatch; pacer queue time and the body read are outside it) (#173). Each tool call's `CallScope` carries a failure budget, `CALL_FAILURE_BUDGET_MS` (40 s, `call-scope.ts`): the time SEC spends failing the call — unanswered-attempt and 5xx waits, backoff, body-idle time — is charged to it and healthy progress never is, attempt and body-idle waits are clamped to what is left, a backoff is slept only while the budget outlasts it, and once it is spent no further attempt or backoff starts and the request fails as `sec_unreachable` or, after a 5xx, `sec_unavailable`, so a call against an unresponsive SEC settles inside the MCP client's 60 s default; the caller's `ctx.signal` reaches every pacer wait, fetch, body read, and backoff, and a cancel rethrows untouched, never retried or counted as an SEC failure (#179). Every body is read inside that ladder, in `rawFetch`'s one body reader (`readBody`), so a 2xx whose body fails after its headers — the connection breaks off, invalid chunk framing or compression, or no bytes for `BODY_IDLE_TIMEOUT_MS` (15 s between reads, never across the whole body, so a body still arriving is never cut) — retries the same way; a probe whose headers arrive has already reopened the gate, and only its own call retries the body. The error body is read there too: a non-retryable status's or a last-attempt 5xx's body is captured through `readBody` (`errorBodyHead`: the first 500 bytes, `…` when cut short, never a partial code point) as a log-only diagnostic — it rides the error's `cause`, whose `data` the call's failure log record writes, never the error's own `data`, which the caller receives (#244) — so one that stalls after its headers ends at the 15 s idle limit or the budget left — keeping what arrived, its wait charged to the budget — and the caller's cancel ends it at once as cancellation (#202). A body the ladder has no use for — a 404's, a retried 5xx's (released before its backoff), a 429's, an answer landing as the caller cancels — is cancelled unread (#188); an error a spent budget ends with from a retried 5xx therefore logs no body. A 200 that reads whole but is not JSON where JSON is expected fails on its one request, unretried (#181). EDGAR full-text search answers a failure of its search backend with a 200 whose JSON carries `errorType` (its OpenSearch client's error class) in place of hits; `searchFilings` and `resolveEntityByName` opt in to classifying that body (`ReadOptions.backendFailure`), so `ConnectionError`, `TimeoutError`, and `NoLivingConnectionsError` fail the attempt on this ladder like a 5xx — same attempts, backoff, block-gate and pacer re-admission, budget, and cancel — and end as `efts_degraded_response` with `retryable: true`, while any other `errorType` (a `ResponseError` is the cluster refusing the request) fails on its one request with `retryable: false`; both carry `upstreamErrorType` and `upstreamErrorMessage`, bounded like the error body, never the body's `trace` or `requestId`, and the entity lookup throws instead of reading the body as no match (#206). So does a submissions document or archive page whose JSON lacks what its readers index — `filings.recent`'s (or the page's) six columns `accessionNumber`, `filingDate`, `form`, `primaryDocument`, `primaryDocDescription`, `reportDate` as arrays, an array `filings.files`, array `tickers` and `exchanges` — checked in `getSubmissions` / `fetchArchivePage` before the cache write, so nothing is cached and the next call refetches (#186). Empty arrays pass; lengths and optional columns are not checked. When the last attempt gets no complete, readable answer — whatever the earlier ones got — the call fails as `ServiceUnavailable` with `data.reason: 'sec_unreachable'`, `retryable: true`, `url`, and a hint, declared beside `rate_limited` on the same tools; the message says which case (no response, a body that failed to read, a body that is not the JSON the request reads) and names host, attempts, and the transport code or the timeout, never the request URL, and the runtime's own text rides `cause` to the log only (#173, #181). When the last attempt answers 500, 502, 503, or 504 — whatever the earlier ones got — the call fails as `ServiceUnavailable`, a 504 too (it is SEC's gateway failing, as #173 codes this service's own header timeout; `data.status` keeps 504), with `data.reason: 'sec_unavailable'`, `retryable: true`, and a hint that SEC failed on its side and the same call can be retried in a minute, declared beside `sec_unreachable` on the same tools; its message reads like `sec_unreachable`'s (`SEC EDGAR (www.sec.gov) answered HTTP 503 on the last of 3 attempts.`, or `… on attempt 2 of 3; retries stopped at this call's 40 s budget for SEC failures.`), and the rest of `data` is the status mapping's: `url`, `status`, `statusText`, `statusCode`, and `retryAfter` when SEC sends `Retry-After` (#233), with SEC's body on the `cause` chain for the log (#244). `createApp({ teardown })` disposes the pacer through `disposeEdgarApiService()` (#116)
|
|
86
86
|
- **Parameter names:** one name per concept across tools — `company` (the entity a tool reads; on `get_institutional_holdings` that is the 13F filer), `filed_after` / `filed_before` (inclusive filing-date bounds), `forms`. Every tool carrying one of those keys declares `inputAliases` for the other spellings in use — `ticker`, `cik`, `ticker_or_cik` → `company`; `start_date`, `date_from` → `filed_after`; `end_date`, `date_to` → `filed_before`; `form_types` → `forms` — so a caller carrying a name from one tool to the next is not rejected (#115). An alias is declared only where it maps to exactly one key of that tool and its value shape fits: a singular `form_type` cannot fill the `forms` array, so it is left out rather than widening the schema. A tool whose only company input carries another name takes the same company-identifier spellings onto it — `company`, `ticker`, `cik`, `ticker_or_cik` → `issuer` on `find_holders` and `get_beneficial_owners`, and those plus `name` and `search` → `query` on `company_search` — since the key it moves into has no other reading there; the canonical names stay, because renaming them would break existing callers (#152). `fund` (a fund or series) and `companies` (an array) are not aliased. `company_search`'s `filing_limit` → `limit` on `search_filings`, `get_material_events`, and `get_beneficial_owners`, whose one count input counts filings; rewritten before validation, it meets `limit`'s own cap and bound in either `EDGAR_CLAMP_OVERSIZED_LIMITS` mode. A `limit` counting managers, transactions, positions, companies, or data points takes no such alias, and `company_search` takes no `limit` alias, since there it would read as a count of companies (#212). Every tool with the date pair accepts either bound alone. `search_filings` fills the missing one before routing, since EDGAR full-text search ignores a one-sided custom range: a lone `filed_after` runs through today (UTC), a lone `filed_before` starts at 2001-01-01, or at 1993-01-01 when it falls before 2001, and the full-text path discloses a filled window in `effectiveQuery` as `(filed <after> to <before>)` (#185)
|
|
87
87
|
- **User-Agent required:** `"AppName contact@email.com"` on every SEC request or IP gets blocked
|
|
88
88
|
- **CIK zero-padding:** the `data.sec.gov` APIs (submissions, companyfacts, companyconcept) require the 10-digit zero-padded CIK (`String(cik).padStart(10, '0')`). Archive paths under `www.sec.gov/Archives/edgar/data/` take it unpadded — SEC answers the padded path with a 301, and `fetch` follows it inside the same pacer slot, so every archive read would cost two requests. `filingArchiveUrl` (exported from `edgar-api-service.ts`) strips the zeros for all seven archive reads and for `get_filing`'s `filing_url` (#156)
|
|
89
89
|
- **ETF/mutual-fund tickers:** `loadTickerCache` fetches `company_tickers_mf.json` alongside `company_tickers.json` and merges fund symbols (VOO, SCHD, JEPI…) into `byTicker`. Fund CIKs are registrant trusts (1:many with series), so fund rows go into `byTicker` only — never `byCik`, whichever source they come from. Resolved fund matches carry `seriesId`/`classId` from the live MF file, the only source of either. With the mirror on and `EDGAR_MIRROR_FALLBACK_LIVE` on, the equity rows come from the live `company_tickers.json` every TTL as with no mirror, the live MF file is merged in, and the mirror's fund rows join behind it, so a fund symbol resolves when the live fund file lacks it or fails to load, and when the mirror predates MF ingestion (#43, #234). When `company_tickers.json` fails there — any failure, a rate-limit refusal included — `loadTickerBase` builds the index from all the mirror's rows, which stands for the full TTL with no retry window (it is complete, only stale), and logs one warning carrying `endpoint: 'company_tickers'`. Strict mirror-only (`FALLBACK_LIVE=false`) uses the mirror's rows alone (ticker→CIK, no series/class) and sends nothing; an empty ticker layer fails there as not synced. The mirror stores a fund symbol with an empty name — its schema has no series column — and `mirrorIndexRow` reads that empty name as the fund marker; a symbol claims `byTicker` in the order equity → live fund → mirror fund, so a live entry supersedes the mirror's bare row and keeps its series (#135). **The live fund slice has its own failure window:** a failed MF load (any HTTP failure, a malformed body, the block gate's refusal) is not cached for the ticker-cache TTL — `loadMfTickers` returns no rows and a `retryAt` `FUND_SLICE_RETRY_MS` (60 s) out, or the error's `retryAfter` when longer, so nothing is retried while the gate is closed. The first resolution after it refetches the file once, single-flight, onto the cached base (`reloadFundSlice`), which keeps its own load time: the equity index is not refetched and its TTL does not move. A per-resolution retry was rejected — against a persistent 5xx it adds three requests and ~3 s of backoff to every lookup (#119). Each failed load logs one warning through the framework's global `logger` (no request context to attach to) carrying `endpoint: 'company_tickers_mf'` (never the URL — framework log guidance keeps URLs out of log fields), the HTTP status or `malformed_body`, and the retry delay (#43).
|
|
90
|
-
- **Name and ticker resolution:** `resolveCik` walks numeric CIK → the listed-symbol lookup (`listedSymbol`), for 1–5 letters in any case and for anything typed in uppercase → for input typed in uppercase, the ticker-spelling readings (`readTickerSpelling`) → the name passes (exact → exact once folded → exact once initials join → prefix → substring over `allEntries`) → for input not typed in uppercase, the listed-symbol lookup the first step skipped. Four normalizations hang off that chain. The name passes' **exact** tiers also compare suffix-normalized forms (`normalizeCompanySuffix`): the terminal whitespace-delimited token only, a trailing `.`/`,` stripped as part of recognizing it, expanded to one of four canonical long forms — `corp`→`corporation`, `inc`→`incorporated`, `co`→`company`, `ltd`→`limited`. **The four buckets are never merged.** The registry carries distinct registrants differing only in which suffix they use (`TORO CO` 0000737758 vs `TORO CORP.` 0001941131, and the same shape on Blue Owl and Fluent), so a single "has a corporate suffix" marker would compare two companies equal. Only the terminal token is rewritten — the same words sit mid-name in titles ending in a different suffix (`American Water Works Company, Inc.`) — and a terminal token that merely contains one (`Ltd./ADR`) is not a suffix. Punctuation elsewhere in a name is the fold's (below). `llc`/`plc` and the `lp`/limited-partnership family get no bucket and must never fold into the `ltd` bucket (#107); they drop for a bare query (below) but never normalize into one of the four. The name passes **resolve within the best tier a current name reaches**: several CIKs there are the ambiguity, listed without the tiers below, so `Itron` resolves to ITRON, INC. instead of listing SOLITRON and POSITRON beside it. The exact tier also matches a registry name minus its terminal suffix and a comma before it (`stripCompanySuffix` over `DROPPABLE_SUFFIXES`: the four buckets plus `plc`, `llc`, `lp`, `nv`, `sa`, `ag`, and `se`, with or without periods), so `Apple` names `Apple Inc.` exactly. The wider set is deliberate: with the four buckets alone, `Rio Tinto` silently picked RIO TINTO LTD over RIO TINTO PLC; now both drop to an exact hit and tie. Only the registry side is stripped, so `Toro Co` never meets `TORO CORP.` and `Rio Tinto plc` never meets RIO TINTO LTD, and two suffix variants of one base name (`Blue Owl Capital`) tie. Current names (registry rows, which carry a ticker) choose the tier. A former name joins at that tier or better but never outranks one — otherwise `Travelers` resolves to Citigroup through its former name `travelers inc` — and decides alone only when no current name matches (`Facebook Inc`). Against the 2026-10-02 registry plus the former-names asset, 930 of 34,865 name queries move from ambiguous to resolved and no resolved CIK changes (#155). The **punctuation fold** (`foldNamePunctuation`, #210) deletes `,` `.` `'` `’` from the query and from every current and former name, then collapses each whitespace run to one space (#219), so `QXO Inc` meets `QXO, Inc.`, `Fluent Inc` meets `Fluent, Inc.`, `Jeffs Brands` the former name `jeffs' brands ltd`, and `Forgent Networks Inc` the former name `forgent networks inc`; a period is deleted, never spaced, so `U.S. Bancorp` meets `US BANCORP \DE\`. It is comparison-only — returned names and `suggestCompanies` never see it — and a helper of its own: `normalizeCompanySuffix` and `stripCompanySuffix` read the as-written strings, and the folded tiers run them again on the folded forms. Without the fold a weaker tier answered a punctuation-free spelling with another registrant (`BlackRock Inc` reached BLACKROCK INCOME TRUST, INC. by prefix, `Block Inc` H&R BLOCK INC by substring). Against the 2026-11-03 registry plus the former-names asset, no title queried as listed changes its answer and no title or former name changes CIK; six former names typed as listed now match several companies, the current registrant listed first, since a current title now matches them too (`energizer holdings inc` lists ENERGIZER HOLDINGS, INC. ahead of the former holder). The **initials join** (`joinSpacedInitials`, #219) turns each run of two or more one-letter words in a folded form into one word (`j m smucker co` → `jm smucker co`), so `JM Smucker` and `J.M. Smucker` meet `J M SMUCKER Co` and `WP Carey` meets `W. P. Carey Inc.`; it is comparison-only like the fold, and its tier runs the suffix helpers again on the joined forms. **No hit starts or ends inside a word** (#218): a prefix must end at a word boundary of the joined name and a substring must start at one in the name as written — a boundary is regex `\b`, a letter or digit on exactly one side — so `SY Bancorp, Inc.` no longer names Embassy Bancorp through `embassy`, `helix acquisition corp ii` no longer lists the later `Helix Acquisition Corp. III`, and `ticker:MRO` (a delisted symbol) no longer scopes to PermRock Royalty Trust. Tier order: exact as written, exact once folded, exact once initials join, prefix of the joined form, substring as written. Each tier ranks above the looser one after it, so a title typed as listed never ties a former name equal to it only once folded (`McGraw Hill, Inc.` stays alone beside S&P Global's former `mcgraw hill inc`), and `US Gold` names U.S. GOLD CORP. alone instead of tying McEwen's former `u s gold corp`, equal only once joined. Substring stays as written, so a query ending mid-word still reaches a name containing it as written (`Berkshire Hath`) but never one containing it only once folded: `Helix Acquisition Corp. III` folds to a name holding `helix acquisition corp ii`. A query with no letter or digit (`.`, `'`) is `no_match` instead of folding to a string that starts every name. Against the 2026-11-03 registry plus the former-names asset (#218, #219), no title queried as listed changes its answer; of the former names typed as listed, nine that matched several companies now resolve to their own CIK (`ace ltd` no longer lists MDA Space Ltd. beside Chubb), `total` keeps its CIK in a different list, and `u s gold corp` now matches several, U.S. GOLD CORP. first; 174 of the 178 joined or dotted spellings of the 63 names that space their initials resolve to their own CIK, against 15 before, the other four naming U.S. GOLD CORP.; and all 37 double-spaced former names resolve typed single-spaced, against 17 before. Only a query with no letter or digit loses its match, but a query cut short mid-word that the prefix tier answered alone can now list several companies (`baldw` lists Baldwin Insurance Group beside Matson, whose former name is `alexander & baldwin inc`). `\DE\`-style state tags, `&` `-` `/`, and a dotted word SEC splits in two (`AMAZON COM INC` for `Amazon.com`) stay out of scope. The **listed-symbol lookup** retries a dotted symbol with `.`→`-` on a miss — brokers and market data write `BRK.B` where `company_tickers.json` lists `BRK-B`, and that file carries exactly one dotted ticker, `ALDF.U` (a unit of Aldel Financial II, CIK 2031561), with no `ALDF-U` beside it, so the substitution cannot land on the wrong registrant (#110). It answers ahead of the name passes for 1–5 letters in any case and for anything typed in uppercase, so neither a reading nor the period fold ever takes a symbol the file lists; a symbol typed in mixed or lower case outside that shape (`brk.b`) meets it after the name passes, as before. **The ticker-spelling readings** (`listing-codes.ts`, #235) take input typed in uppercase that the lookup missed, before the name passes, whose period fold read `GS.K` as GSK plc, `SU.N` as SUN, and `CF.N` as CFN Enterprises: a US venue code after a listed symbol (`N` `O` `OQ` `A` `P` `K` `PK`; `UEC.N` → UEC, `BIP.PA.N` → BIP-PA); a preferred class run together, `<base>P<letter>` or `<base>PR<letter>` with a base of two or more letters, read as the listed `<base>-P<letter>` (`CFGPH` → CFG-PH, `PCGPRE` → PCG-PE; one-letter bases such as `C-PN` are left out, since `TPC` is Tutor Perini); and a root with no listing of its own, read as the company its hyphenated classes belong to (`GLOP` → GasLog Partners LP), or `ambiguous_company` when they belong to several. A non-US exchange code (`ME` `L` `HK` `T` `TO`: `7203.T`) is no match, and each tool's not-found message appends `nonUsListingNote`'s sentence saying EDGAR indexes SEC registrants by US ticker, name, or CIK. A match a reading produced carries `CikMatch.reading` (`UEC.N read as UEC (URANIUM ENERGY CORP)`; a root names its classes), which `search_filings` puts in `effectiveQuery`'s scope parenthetical (`(entity scope: CIK 0001334933, UEC.N read as UEC (URANIUM ENERGY CORP))`), `compare_companies` in one `caveats` line per input, and the other nine tools in a `resolvedAs` enrichment field, never `notice`, which each writes later and which is last-wins. Uppercase only, so `Ang` and `oak` keep their name-pass candidate lists; the accepted cost is a two-letter dotted initialism typed in uppercase without its closing period reading as a venue code — `B.P` as B (Barrick), `H.P` as H (Hyatt), `W.P` as W (Wayfair), `J.P` as J (Jacobs) — while `B.P.`, `H.P.`, and `b.p` still reach BP and HP. `search_filings`' `ticker:` token gets all of it through `resolveCik` with no change of its own. **No consumer reads the first of several matches** (#223): `company_search`, `get_material_events`, `get_financials`, `get_snapshot`, `get_insider_transactions`, and `search_filings`' `ticker:` token throw `ambiguous_company` (`ValidationError`, one reason and one wording across the six, #228; `data.matches` of `cik`/`name`/`ticker`, the first 10, also listed in the message, and `data.total_matches`, the full count) before any SEC read; `find_holders` and `get_beneficial_owners` `ambiguous_issuer`, `get_institutional_holdings` `ambiguous_entity`, `get_fund_holdings` `ambiguous_fund`, and `compare_companies` reports a per-company `failed[]` reason `ambiguous`. `search_filings`' `cik:` token resolves a zero-padded CIK, which never matches several. `resolveCik` returns every candidate of its best tier, uncut, and `ambiguousMatches` (`src/mcp-server/tools/ambiguous-matches.ts`) is the one cut every ambiguity error shares: the first 10 in resolution order, `data.total_matches` beside them, and, when the list is partial, a message ending `Showing 10 of 66 matches; for one not listed, retry with a fuller name, its ticker, or its CIK.` — `retry with its ticker or CIK.` for `search_filings`' `ticker:` token, which takes no spaces and so no fuller name. Its consumers are the six `ambiguous_company` tools, the four role-specific tools (each keeping its own reason, item wording, and hint), and `compare_companies`' ambiguous `failed_companies[].message`, which takes the list and the sentence and no field. `get_institutional_holdings`' fallback for a name the registry misses, EDGAR entity search (`resolveEntityByName`, `keysTyped=`), returns SEC's first 10 hits beside SEC's `hits.total`, which becomes `data.total_matches` — `of at least 10,000`, with `data.total_matches_is_lower_bound: true`, when its `relation` is `gte`, a floor (#230). When no `compare_companies` input resolves, `no_companies_resolved`'s message repeats each input's `failed_companies[].message`, so `content[]` names the same reasons and candidates as `data.failed_companies` (#231). The 5-candidate cut it replaces hid 61 of `American`'s 66 candidates, American Airlines among them, behind a list that read as complete (#229).
|
|
90
|
+
- **Name and ticker resolution:** `resolveCik` walks numeric CIK → the listed-symbol lookup (`listedSymbol`), for 1–5 letters in any case and for anything typed in uppercase; its answer never changes, but a symbol an earlier, different company held carries a `reading` naming that holder (#237) → for input typed in uppercase, the ticker-spelling readings (`readTickerSpelling`) → the name passes (exact → exact once folded → exact once initials join → prefix → substring over `allEntries`), weighed for input typed in uppercase against a former ticker (`readFormerTicker`, below) → only when no tier matches and the query has two or more words, the word-order tier → for input not typed in uppercase, the listed-symbol lookup the first step skipped, then a former ticker. An uppercase former ticker answers ahead of the names unless a current name is the input exactly (`CHUBB` stays Chubb Ltd, not CommerceHub), or its holder is listed no more and the names find one company (`DINE` stays Dine Brands, not Rewards Network): it reads `BK` as BNY over BK Technologies Corp, whose name only starts with it, and settles `STR`, which starts many names. Lowercase input keeps the name passes first (`bk` keeps its name-pass answer; `amrk` reaches Gold.com). **The word-order tier (#236)** compares a query's words as a set: the key is the joined form (initials joined) with its terminal suffix normalized, words sorted, and a current or former name meets it under the same key, or under its key with the terminal suffix dropped, so `Charles Schwab` names SCHWAB CHARLES CORP and `JB Hunt Transport Services` HUNT J B TRANSPORT SERVICES INC. Names of one word never reach it, the query's own suffix is never dropped, current names list before former ones, and several CIKs list as the ambiguity. It runs only when every name tier misses, so it changes no answer that resolves without it, and it lives in `resolveCik` because EDGAR's entity index (below) answers `Charles Schwab` with a 2008–2010 Reg D filer's exact hit, and index hits come after every local tier. **`company_search` alone then tries the network** when `resolveCik` returns no match: EDGAR's entity index (`resolveEntityByName`, `keysTyped=`, SEC's first 10 hits), then one quoted full-text search of 10-K subsidiaries exhibits (`findSubsidiaryParents`). SEC's trailing ticker list is split from each index name (`SCHWAB CHARLES CORP (SCHW, SCHW-PJ, SCHW-PD)` → name `SCHWAB CHARLES CORP`, ticker `SCHW`), and the hits are ranked on name tiers 0–4: one CIK at an exact tier (0–2) resolves, with a `resolvedAs` reading; several at the best tier fail `ambiguous_company`, with SEC's `hits.total` as `total_matches` when SEC returned only part of its hits (#230); a lone hit at the prefix or substring tier is a near match (Near-match suggestions). Only when no index hit reaches a tier does the exhibits search run: the filers of an EX-21 hit go in the `no_match` message and `data.parents`, ticker-file filers first, then the newest exhibit, and any other document's hit is never named, since a lender's schedule of investments or a competitor's narrative says nothing about ownership; with no EX-21 hit the message points to `secedgar_search_filings` with the quoted name, its JSON arguments passed as an error `literals` value so `content[]` prints them as code, unescaped. A non-US listing code (`7203.T`), a query with no letter or digit, and any query a local pass answers send no request, and strict mirror mode runs both steps, since EFTS is not mirrored. **An index failure fails the call with its reason** (`efts_degraded_response`, `sec_unavailable`, `rate_limited`), never `no_match`, because the server then cannot say whether the company exists; **an exhibits-search failure keeps `no_match`** (SEC unavailable or a rate-limit refusal) and says that search did not run, since the answer is already `no_match` and no request follows it. The caller's cancel rethrows from either step. Four normalizations hang off the name passes. The name passes' **exact** tiers also compare suffix-normalized forms (`normalizeCompanySuffix`): the terminal whitespace-delimited token only, a trailing `.`/`,` stripped as part of recognizing it, expanded to one of four canonical long forms — `corp`→`corporation`, `inc`→`incorporated`, `co`→`company`, `ltd`→`limited`. **The four buckets are never merged.** The registry carries distinct registrants differing only in which suffix they use (`TORO CO` 0000737758 vs `TORO CORP.` 0001941131, and the same shape on Blue Owl and Fluent), so a single "has a corporate suffix" marker would compare two companies equal. Only the terminal token is rewritten — the same words sit mid-name in titles ending in a different suffix (`American Water Works Company, Inc.`) — and a terminal token that merely contains one (`Ltd./ADR`) is not a suffix. Punctuation elsewhere in a name is the fold's (below). `llc`/`plc` and the `lp`/limited-partnership family get no bucket and must never fold into the `ltd` bucket (#107); they drop for a bare query (below) but never normalize into one of the four. The name passes **resolve within the best tier a current name reaches**: several CIKs there are the ambiguity, listed without the tiers below, so `Itron` resolves to ITRON, INC. instead of listing SOLITRON and POSITRON beside it. The exact tier also matches a registry name minus its terminal suffix and a comma before it (`stripCompanySuffix` over `DROPPABLE_SUFFIXES`: the four buckets plus `plc`, `llc`, `lp`, `nv`, `sa`, `ag`, and `se`, with or without periods), so `Apple` names `Apple Inc.` exactly. The wider set is deliberate: with the four buckets alone, `Rio Tinto` silently picked RIO TINTO LTD over RIO TINTO PLC; now both drop to an exact hit and tie. Only the registry side is stripped, so `Toro Co` never meets `TORO CORP.` and `Rio Tinto plc` never meets RIO TINTO LTD, and two suffix variants of one base name (`Blue Owl Capital`) tie. Current names (registry rows, which carry a ticker) choose the tier. A former name joins at that tier or better but never outranks one — otherwise `Travelers` resolves to Citigroup through its former name `travelers inc` — and decides alone only when no current name matches (`Facebook Inc`). Against the 2026-10-02 registry plus the former-names asset, 930 of 34,865 name queries move from ambiguous to resolved and no resolved CIK changes (#155). The **punctuation fold** (`foldNamePunctuation`, #210) deletes `,` `.` `'` `’` from the query and from every current and former name, then collapses each whitespace run to one space (#219), so `QXO Inc` meets `QXO, Inc.`, `Fluent Inc` meets `Fluent, Inc.`, `Jeffs Brands` the former name `jeffs' brands ltd`, and `Forgent Networks Inc` the former name `forgent networks inc`; a period is deleted, never spaced, so `U.S. Bancorp` meets `US BANCORP \DE\`. It is comparison-only — returned names and `suggestCompanies` never see it — and a helper of its own: `normalizeCompanySuffix` and `stripCompanySuffix` read the as-written strings, and the folded tiers run them again on the folded forms. Without the fold a weaker tier answered a punctuation-free spelling with another registrant (`BlackRock Inc` reached BLACKROCK INCOME TRUST, INC. by prefix, `Block Inc` H&R BLOCK INC by substring). Against the 2026-11-03 registry plus the former-names asset, no title queried as listed changes its answer and no title or former name changes CIK; six former names typed as listed now match several companies, the current registrant listed first, since a current title now matches them too (`energizer holdings inc` lists ENERGIZER HOLDINGS, INC. ahead of the former holder). The **initials join** (`joinSpacedInitials`, #219) turns each run of two or more one-letter words in a folded form into one word (`j m smucker co` → `jm smucker co`), so `JM Smucker` and `J.M. Smucker` meet `J M SMUCKER Co` and `WP Carey` meets `W. P. Carey Inc.`; it is comparison-only like the fold, and its tier runs the suffix helpers again on the joined forms. **No hit starts or ends inside a word** (#218): a prefix must end at a word boundary of the joined name and a substring must start at one in the name as written — a boundary is regex `\b`, a letter or digit on exactly one side — so `SY Bancorp, Inc.` no longer names Embassy Bancorp through `embassy`, `helix acquisition corp ii` no longer lists the later `Helix Acquisition Corp. III`, and `ticker:MRO` (a delisted symbol) no longer scopes to PermRock Royalty Trust. Tier order: exact as written, exact once folded, exact once initials join, prefix of the joined form, substring as written. Each tier ranks above the looser one after it, so a title typed as listed never ties a former name equal to it only once folded (`McGraw Hill, Inc.` stays alone beside S&P Global's former `mcgraw hill inc`), and `US Gold` names U.S. GOLD CORP. alone instead of tying McEwen's former `u s gold corp`, equal only once joined. Substring stays as written, so a query ending mid-word still reaches a name containing it as written (`Berkshire Hath`) but never one containing it only once folded: `Helix Acquisition Corp. III` folds to a name holding `helix acquisition corp ii`. A query with no letter or digit (`.`, `'`) is `no_match` instead of folding to a string that starts every name. Against the 2026-11-03 registry plus the former-names asset (#218, #219), no title queried as listed changes its answer; of the former names typed as listed, nine that matched several companies now resolve to their own CIK (`ace ltd` no longer lists MDA Space Ltd. beside Chubb), `total` keeps its CIK in a different list, and `u s gold corp` now matches several, U.S. GOLD CORP. first; 174 of the 178 joined or dotted spellings of the 63 names that space their initials resolve to their own CIK, against 15 before, the other four naming U.S. GOLD CORP.; and all 37 double-spaced former names resolve typed single-spaced, against 17 before. Only a query with no letter or digit loses its match, but a query cut short mid-word that the prefix tier answered alone can now list several companies (`baldw` lists Baldwin Insurance Group beside Matson, whose former name is `alexander & baldwin inc`). `\DE\`-style state tags, `&` `-` `/`, and a dotted word SEC splits in two (`AMAZON COM INC` for `Amazon.com`) stay out of scope. The **listed-symbol lookup** retries a dotted symbol with `.`→`-` on a miss — brokers and market data write `BRK.B` where `company_tickers.json` lists `BRK-B`, and that file carries exactly one dotted ticker, `ALDF.U` (a unit of Aldel Financial II, CIK 2031561), with no `ALDF-U` beside it, so the substitution cannot land on the wrong registrant (#110). It answers ahead of the name passes for 1–5 letters in any case and for anything typed in uppercase, so neither a reading nor the period fold ever takes a symbol the file lists; a symbol typed in mixed or lower case outside that shape (`brk.b`) meets it after the name passes, as before. **The ticker-spelling readings** (`listing-codes.ts`, #235) take input typed in uppercase that the lookup missed, before the name passes, whose period fold read `GS.K` as GSK plc, `SU.N` as SUN, and `CF.N` as CFN Enterprises: a US venue code after a listed symbol (`N` `O` `OQ` `A` `P` `K` `PK`; `UEC.N` → UEC, `BIP.PA.N` → BIP-PA); a preferred class run together, `<base>P<letter>` or `<base>PR<letter>` with a base of two or more letters, read as the listed `<base>-P<letter>` (`CFGPH` → CFG-PH, `PCGPRE` → PCG-PE; one-letter bases such as `C-PN` are left out, since `TPC` is Tutor Perini); and a root with no listing of its own, read as the company its hyphenated classes belong to (`GLOP` → GasLog Partners LP), or `ambiguous_company` when they belong to several. A non-US exchange code (`ME` `L` `HK` `T` `TO`: `7203.T`) is no match, and each tool's not-found message appends `nonUsListingNote`'s sentence saying EDGAR indexes SEC registrants by US ticker, name, or CIK. A match a reading produced carries `CikMatch.reading` (`UEC.N read as UEC (URANIUM ENERGY CORP)`; a root names its classes), which `search_filings` puts in `effectiveQuery`'s scope parenthetical (`(entity scope: CIK 0001334933, UEC.N read as UEC (URANIUM ENERGY CORP))`), `compare_companies` in one `caveats` line per input, and the other nine tools in a `resolvedAs` enrichment field, never `notice`, which each writes later and which is last-wins. Uppercase only, so `Ang` and `oak` keep their name-pass candidate lists; the accepted cost is a two-letter dotted initialism typed in uppercase without its closing period reading as a venue code — `B.P` as B (Barrick), `H.P` as H (Hyatt), `W.P` as W (Wayfair), `J.P` as J (Jacobs) — while `B.P.`, `H.P.`, and `b.p` still reach BP and HP. `search_filings`' `ticker:` token gets all of it through `resolveCik` with no change of its own. **No consumer reads the first of several matches** (#223): `company_search`, `get_material_events`, `get_financials`, `get_snapshot`, `get_insider_transactions`, and `search_filings`' `ticker:` token throw `ambiguous_company` (`ValidationError`, one reason and one wording across the six, #228; `data.matches` of `cik`/`name`/`ticker`, the first 10, also listed in the message, and `data.total_matches`, the full count) before any SEC read; `find_holders` and `get_beneficial_owners` `ambiguous_issuer`, `get_institutional_holdings` `ambiguous_entity`, `get_fund_holdings` `ambiguous_fund`, and `compare_companies` reports a per-company `failed[]` reason `ambiguous`. `search_filings`' `cik:` token resolves a zero-padded CIK, which never matches several. `resolveCik` returns every candidate of its best tier, uncut, and `ambiguousMatches` (`src/mcp-server/tools/ambiguous-matches.ts`) is the one cut every ambiguity error shares: the first 10 in resolution order, `data.total_matches` beside them, and, when the list is partial, a message ending `Showing 10 of 66 matches; for one not listed, retry with a fuller name, its ticker, or its CIK.` — `retry with its ticker or CIK.` for `search_filings`' `ticker:` token, which takes no spaces and so no fuller name. Its consumers are the six `ambiguous_company` tools, the four role-specific tools (each keeping its own reason, item wording, and hint), and `compare_companies`' ambiguous `failed_companies[].message`, which takes the list and the sentence and no field. `get_institutional_holdings`' fallback for a name the registry misses, EDGAR entity search (`resolveEntityByName`, `keysTyped=`), returns SEC's first 10 hits beside SEC's `hits.total`, which becomes `data.total_matches` — `of at least 10,000`, with `data.total_matches_is_lower_bound: true`, when its `relation` is `gte`, a floor (#230). When no `compare_companies` input resolves, `no_companies_resolved`'s message repeats each input's `failed_companies[].message`, so `content[]` names the same reasons and candidates as `data.failed_companies` (#231). The 5-candidate cut it replaces hid 61 of `American`'s 66 candidates, American Airlines among them, behind a list that read as complete (#229).
|
|
91
91
|
- **Former-name resolution:** `src/services/edgar/data/former-names.json` is a committed asset (generated offline via `bun run gen:former-names`) containing `[lowercasedFormerName, zeroPaddedCIK]` tuples. `buildTickerCache` folds them into `allEntries` for name search and the trigram pass. Regenerate on demand after major M&A waves — former names are immutable, so the file rarely needs updating.
|
|
92
|
-
- **
|
|
92
|
+
- **Former-ticker resolution (#237):** `src/services/edgar/data/former-tickers.json` is a committed asset (generated offline via `bun run gen:former-tickers`) of `[TICKER, zeroPaddedCIK, "YYYY-MM", title]` tuples: every symbol → CIK pair a monthly Wayback Machine capture of `company_tickers.json` lists and the live file at generation does not. The month is the latest capture listing the pair — a **capture date, not a delisting date** — and the title is the holder's in that capture. The generator reads Wayback's CDX index once, then each capture sequentially and paced, decodes gzip-encoded bodies, and skips one that does not parse; a capture repeating any digest but the newest one seen so far is a **stale copy** SEC's CDN served again (2019-08 repeats 2017-08's file byte for byte), so it adds no month. Its downloads are cached, so a rerun after a stop resumes. `buildTickerCache` indexes the rows beside `allEntries` (`buildFormerTickerIndex`), and the lookup sends no SEC request, strict mirror mode included. A symbol several companies held resolves to the **most recent holder** rather than failing as ambiguous, so no call that resolves today starts failing; its `reading` names that company (its current name and ticker when listed, else its title as last listed), the capture month, and any earlier holders. A symbol the file still lists answers as listed, and when an earlier, different company held it the `reading` names that holder, its CIK, and the month (`XOM` stays ExxonMobil Holdings Corp and names EXXON MOBIL CORP). A symbol that leaves the file after the asset was generated misses until the next `bun run gen:former-tickers`; run it on demand, as with former names.
|
|
93
|
+
- **Near-match suggestions:** `suggestCompanies(query, allEntries)` runs a Dice-coefficient trigram pass on the zero-hit search path, returning up to 3 candidates above a threshold. Each entry is scored on its **name and its ticker**, keeping the higher of the two — one ranked, deduped, top-N list rather than two disjoint ones, so a strong ticker match can outrank a weak name match and vice versa, and a ticker-shaped miss gets help instead of a bare `no_match` (#111). An entry missing either field is simply not scored on it: former-name entries carry a name and no ticker, and MF rows carry neither a name nor a place in `allEntries`, so fund tickers stay structurally unreachable here regardless of what the scorer does. Suggestions appear in the `no_match` error `data.suggestions` and in the error message. Never auto-resolves. A lone EDGAR entity-index hit that reaches only the prefix or substring name tier leads `data.suggestions`, ahead of the trigram candidates (#236). Only the throw that attaches suggestions or parents names the field in its hint (`company_search` passes its own `recovery.hint`: one sentence per field attached, then the contract text); the contract's `no_match` recovery never mentions it, since a zero-hit miss with no near match and the bare-CIK 404 carry no `suggestions` (#153).
|
|
93
94
|
- **XBRL friendly names:** `concept-map.ts` maps `"revenue"` → real XBRL tags; handles historical tag changes (ASC 606), including both assessed-tax variants — a filer presenting revenue gross of excise/sales tax reports only `RevenueFromContractWithCustomerIncludingAssessedTax`, and without it the walk fell through to tags SEC retired in 2018 (#98). The Including variant sits BEHIND `Revenues`, not ahead of it — the two disagree for filers that tag gross sales and net-of-excise sales under separate elements, so promoting it over `Revenues` swaps the definition partway back through the history and prints a step change that is a tag switch, not a business fact; behind `Revenues` it only fills frames no current tag covers. The same precedent places successor tags: `capex` walks `PaymentsToAcquireProductiveAssets` behind the PP&E-only tag (it also counts software and intangibles) and `interest_expense` walks `InterestExpenseNonoperating` behind both older tags, so NVIDIA, Amazon, Visa, and Microsoft reach current values and no frame the older tags cover changes (#125); the banks' `InterestExpenseOperating` (JPMorgan, Bank of America, and Wells Fargo report interest expense only under it from 2024) goes behind that, since it matches `InterestExpense` for 33 of 37 CY2025Q2 filers reporting both but `InterestExpenseNonoperating` for 0 of 4 (#147). SEC serves both successors with no label, so the line falls back to the concept's label. A different-definition tag still goes in `relatedTags`, never `tags` — `ppe_net`'s finance-lease-inclusive total is the primary line for Alphabet, Meta, and Tesla (#36, #130). `ifrsTags` covers every concept with an IFRS element confirmed present in a live 20-F filer's companyfacts; `notes_payable` is deliberately unmapped (IFRS presents borrowings as one caption, with no notes/debt split) and `shares_outstanding` is `dei`. Never add an `ifrsTags` entry from the taxonomy alone — an element existing is not evidence filers tag it (#99). `ifrsTags` order is semantic the same way `tags` is: index 0 is the counterpart of the us-gaap index-0 tag, so the same concept answers the same question under either taxonomy (`accounts_receivable` leads with the trade-only caption, not the combined trade-and-other one; `share_repurchases` with the financing outflow, not the treasury-only line a share-cancelling filer tags zero). Verify a candidate order against filers that report BOTH tags — presence alone does not settle which one leads. One concept has no right order: IFRS filers split between the employee-scheme share-based-payment element and the IFRS 2.51(a) expense total, and the two invert between filers (SAP's total is its real line with the employee element a two-period fringe; Sanofi is the exact opposite), so `stock_based_compensation` carries `ifrsTagSelection: 'coverage'` and picks per filer by which tag covers more standard periods (#101). It is the only concept that does, and the flag is scoped to `ifrsTags` on purpose — its us-gaap pair IS a ladder, since `AllocatedShareBasedCompensationExpense` is the disaggregated line and out-covers the total for Alphabet, IBM, Tesla, and P&G.
|
|
94
95
|
- **`fetch_frames` reads one tag:** a friendly name sends one frames request, for its first tag; the rest come back in `unqueried_tags` on a success and on `no_data`, whose hint says to query each. Revenue's first tag has no annual frame before CY2014, so an older revenue screen names one of the listed tags directly. The hint names no start year: frame coverage is per tag (#207).
|
|
95
96
|
- **`compare_companies` lists:** `companies` takes the first 10 inputs as given and `concepts` the first 8 distinct known concepts (merged spellings count once, unknown names none); the rest come back in `deferred_companies` / `deferred_concepts` behind `EDGAR_CLAMP_OVERSIZED_LIMITS`, through `batchClamp` in `limit-clamp.ts`, and the 10 x 8 bound keeps the inline-matrix cell ceiling valid (#201). The notice names the re-call — three when both lists defer: deferred companies with the 8 compared concepts, the 10 companies read with deferred concepts, and the two deferred lists together — since a re-call pairing one deferred list with the other full input list passes the other cap and repeats cells another re-call reads; a lone deferred company is paired with one of the 10 in its two re-calls, and that company leaves the second. An input resolving to a CIK an earlier input already holds is read once, under the earlier input, with a caveat like the concept merge's; it still takes a slot (#217).
|
|
@@ -207,7 +208,7 @@ throw notFound('Item not found', { itemId }); // explicit code
|
|
|
207
208
|
throw new Error('Item not found'); // auto-classified → NotFound
|
|
208
209
|
```
|
|
209
210
|
|
|
210
|
-
**HTTP responses.** `httpErrorFromResponse(response, { service, data })` from `/utils` maps the full status table (401/403/408/422/429/5xx) and captures body + `Retry-After`. Used in `EdgarApiService` with `captureBody: false`: the framework's capture awaits each read with no stall bound or signal, so the service reads the 500-byte diagnostic itself through `readBody` and passes it on `data` (#
|
|
211
|
+
**HTTP responses.** `httpErrorFromResponse(response, { service, data })` from `/utils` maps the full status table (401/403/408/422/429/5xx) and captures body + `Retry-After`. Used in `EdgarApiService` with `captureBody: false`: the framework's capture awaits each read with no stall bound or signal, so the service reads the 500-byte diagnostic itself through `readBody` (#202) and passes it as the error's `cause`, never on `data`: the framework keeps off the wire only a body its own capture read, so a body on `data` reaches the caller as given, while the call's failure log record writes each cause's `data` under its `requestId` (#244).
|
|
211
212
|
|
|
212
213
|
See framework CLAUDE.md and the `api-errors` skill for the full reference.
|
|
213
214
|
|
|
@@ -226,6 +227,8 @@ src/
|
|
|
226
227
|
call-scope.ts # Per-call cancel signal + SEC failure budget (#179)
|
|
227
228
|
submissions-archive.ts # Shared archive-page walk (page cap, order, early stop)
|
|
228
229
|
filing-headers.ts # SEC submission-header parsers
|
|
230
|
+
listing-codes.ts # Ticker-spelling readings (venue codes, preferred classes, class roots) + non-US listing note
|
|
231
|
+
former-tickers.ts # Former-ticker index and readings (#237)
|
|
229
232
|
concept-map.ts # Friendly name → XBRL tag mapping + taxonomy/tag resolution
|
|
230
233
|
concept-series.ts # Shared frame dedup, tag selection, staleness caveats
|
|
231
234
|
trigram-similarity.ts # Dice trigram scorer for near-match suggestions
|
|
@@ -237,6 +240,9 @@ src/
|
|
|
237
240
|
nport-parser.ts # NPORT-P header (series routing) + full report
|
|
238
241
|
filing-to-text.ts # HTML / SGML submission → plain text
|
|
239
242
|
types.ts # Domain types
|
|
243
|
+
data/
|
|
244
|
+
former-names.json # Committed asset: former registrant names (bun run gen:former-names)
|
|
245
|
+
former-tickers.json # Committed asset: former ticker → CIK pairs from Wayback captures (bun run gen:former-tickers)
|
|
240
246
|
mirror/ # Opt-in local SQLite mirror (framework MirrorService)
|
|
241
247
|
edgar-mirror.ts # two stores + ready-gated read helpers
|
|
242
248
|
tickers-sync.ts # company_tickers.json ingester
|
|
@@ -253,7 +259,7 @@ src/
|
|
|
253
259
|
tools/format-usd.ts # USD amounts scaled by magnitude (T/B/M/K, sign before the $) and every-digit grouping for content[] (#222)
|
|
254
260
|
tools/form-filter.ts # `forms` normalization (trim, uppercase, drop blanks) shared by search_filings and company_search (#194)
|
|
255
261
|
tools/limit-clamp.ts # Over-cap numeric inputs served at the cap (#197) and ID lists answered to the cap (#201), behind EDGAR_CLAMP_OVERSIZED_LIMITS
|
|
256
|
-
tools/resolved-as.ts # The `resolvedAs` enrichment field of the company-resolving tools (how an unlisted ticker spelling
|
|
262
|
+
tools/resolved-as.ts # The `resolvedAs` enrichment field of the company-resolving tools (how an input was read: an unlisted ticker spelling #235, a former ticker or earlier holder #237, an entity-index match #236)
|
|
257
263
|
tools/sec-upstream-errors.ts # The `rate_limited`, `sec_unreachable`, and `sec_unavailable` error-contract entries every SEC-reaching tool spreads into its `errors`
|
|
258
264
|
tools/definitions/
|
|
259
265
|
index.ts # buildToolDefinitions() — the createApp() tool list, drop tool gated via disabledTool(), clamped tools built from clampOversizedLimits
|
|
@@ -279,6 +285,9 @@ src/
|
|
|
279
285
|
filing-types.resource.ts
|
|
280
286
|
prompts/definitions/
|
|
281
287
|
company-analysis.prompt.ts
|
|
288
|
+
scripts/
|
|
289
|
+
gen-former-names.ts # Offline generator for data/former-names.json (never part of the build)
|
|
290
|
+
gen-former-tickers.ts # Offline generator for data/former-tickers.json: Wayback captures of company_tickers.json
|
|
282
291
|
```
|
|
283
292
|
|
|
284
293
|
---
|
package/README.md
CHANGED
|
@@ -82,6 +82,8 @@ The skill ships in `skills/secedgar-guide/SKILL.md`. Plugin hosts load it from t
|
|
|
82
82
|
|
|
83
83
|
- `query` takes a ticker (equities, ETFs, mutual funds), a current or former company name, or a CIK; `include_filings` (default on) adds up to `filing_limit` filings (default 10; a value up to 1,000 is served at the 50 inline cap), filtered by `forms`, `filed_after`, and `filed_before`
|
|
84
84
|
- An uppercase ticker also resolves as market-data feeds write it: venue-coded (`UEC.N`), a preferred class run together (`CFGPH`), or a root listed only as share classes (`GLOP`); `resolvedAs` says how it was read (`UEC.N read as UEC (URANIUM ENERGY CORP)`), and a non-US listing such as `7203.T` fails `no_match` with a note that EDGAR indexes SEC registrants by US ticker, name, or CIK
|
|
85
|
+
- A ticker SEC's file no longer lists resolves to the company that held it last (`AMRK` → Gold.com, Inc.), and a listed ticker an earlier company held names that company in `resolvedAs` (`XOM`). A name whose words are in another order also matches when nothing else does (`Charles Schwab` → SCHWAB CHARLES CORP)
|
|
86
|
+
- A name SEC's ticker file lacks is looked up in EDGAR's entity index of every filer, which holds filers with no ticker (`Exxon Mobil` → EXXON MOBIL CORP, `resolvedAs` saying so). A private company found only in a 10-K's subsidiaries exhibit (EX-21) fails `no_match` with the filers of that exhibit in `data.parents`
|
|
85
87
|
- Returns SIC code, exchanges, fiscal year end, and state of incorporation, plus `series_id` / `class_id` for a fund ticker; fails as `no_match` (with near matches in `data.suggestions`) or, for a name matching several companies, `ambiguous_company`, listing up to 10 by CIK, name, and ticker to retry with, plus the full count in `total_matches`
|
|
86
88
|
- A date or form filter can reach into the archive (up to 10 pages); `history_scanned_through` reports how far it got
|
|
87
89
|
|
|
@@ -247,7 +249,7 @@ Built on [`@cyanheads/mcp-ts-core`](https://github.com/cyanheads/mcp-ts-core): s
|
|
|
247
249
|
EDGAR-specific:
|
|
248
250
|
|
|
249
251
|
- Requests are paced under SEC's 10 req/s limit; after a 429, calls fail locally as `rate_limited` with a `retryAfter` countdown for `EDGAR_RATE_LIMIT_COOLDOWN_SECONDS`, then one probe goes out
|
|
250
|
-
- CIK resolution from tickers (fund tickers included), current and former company names, or raw CIKs, with near-match suggestions on a miss
|
|
252
|
+
- CIK resolution from tickers (fund and former tickers included), current and former company names (reordered words too), or raw CIKs, with near-match suggestions on a miss; `secedgar_company_search` also tries EDGAR's entity index and 10-K subsidiaries exhibits
|
|
251
253
|
- Friendly XBRL concept names that handle historical tag changes; `secedgar_get_financials`, `secedgar_get_snapshot`, and `secedgar_compare_companies` share the same dedup and tag priority, so their numbers agree, and `caveats` flag gaps in the series
|
|
252
254
|
- Filing documents converted from HTML to text, with heading detection and offset paging for oversized filings
|
|
253
255
|
- Opt-in local SQLite mirror of company tickers and XBRL company-facts (`EDGAR_MIRROR_ENABLED`) that serves CIK resolution and financials from disk
|
|
@@ -0,0 +1,35 @@
|
|
|
1
|
+
---
|
|
2
|
+
summary: "Every company-resolving tool resolves former tickers (AMRK is Gold.com), and secedgar_company_search finds filers with no ticker through EDGAR's entity index and names a private company's parent from 10-K subsidiaries exhibits. SEC's HTTP error bodies go to the server log instead of the error's data."
|
|
3
|
+
breaking: false
|
|
4
|
+
security: false
|
|
5
|
+
---
|
|
6
|
+
|
|
7
|
+
# 0.19.1 — 2026-11-13
|
|
8
|
+
|
|
9
|
+
## Added
|
|
10
|
+
|
|
11
|
+
- **Former tickers resolve in every company-resolving tool** ([#237](https://github.com/cyanheads/secedgar-mcp-server/issues/237)): `AMRK` reads as Gold.com, Inc., and `resolvedAs` names the holder and the latest monthly capture of SEC's ticker file that lists the symbol. The symbols come from a committed asset, `src/services/edgar/data/former-tickers.json`, written by `bun run gen:former-tickers` from the Wayback Machine's monthly captures of the ticker file.
|
|
12
|
+
- **An earlier holder of a listed symbol is named in `resolvedAs`** ([#237](https://github.com/cyanheads/secedgar-mcp-server/issues/237)): `XOM` still resolves to ExxonMobil Holdings Corp and reads that EXXON MOBIL CORP held it before.
|
|
13
|
+
- **A word-order name tier** ([#236](https://github.com/cyanheads/secedgar-mcp-server/issues/236)) matches a multi-word query that reorders a name's words when no other name tier matches: `Charles Schwab` finds SCHWAB CHARLES CORP, `JB Hunt Transport Services` finds HUNT J B TRANSPORT SERVICES INC.
|
|
14
|
+
- **`secedgar_company_search` looks a missed name up in EDGAR's entity index** ([#236](https://github.com/cyanheads/secedgar-mcp-server/issues/236)), which holds filers with no ticker: `Exxon Mobil` resolves to EXXON MOBIL CORP, with `resolvedAs` saying so. When SEC fails the lookup, the call fails with that failure's reason (`efts_degraded_response` among them) rather than `no_match`.
|
|
15
|
+
- **`secedgar_company_search` searches 10-K subsidiaries exhibits (EX-21) when no entity-index hit matches the name** ([#236](https://github.com/cyanheads/secedgar-mcp-server/issues/236)). The filers of a matching exhibit come back in the `no_match` error's `data.parents` (`Vertafore` → ROPER TECHNOLOGIES INC).
|
|
16
|
+
|
|
17
|
+
## Changed
|
|
18
|
+
|
|
19
|
+
- **An uppercase former ticker answers ahead of a name the input only begins or contains** ([#237](https://github.com/cyanheads/secedgar-mcp-server/issues/237)), when its holder is still listed under another symbol or the names find no single company. A current name the input matches exactly, or the one company the names find for a holder listed no more, keeps its answer. Answers that change:
|
|
20
|
+
- `BK` resolves to Bank of New York Mellon Corp (CIK 0001390777, listed as BNY), where 0.19.0 answered BK Technologies.
|
|
21
|
+
- `FORD` resolves to Forward Industries, Inc. (FWDI), where 0.19.0 answered Ford Motor Co; `resolvedAs` says so, and `Ford Motor` or `F` still reaches the automaker.
|
|
22
|
+
- `STR` resolves to its most recent holder, Sitio Royalties, instead of failing as ambiguous.
|
|
23
|
+
- `ticker:MRO` in `secedgar_search_filings` scopes to Marathon Oil instead of failing `unresolved_ticker`.
|
|
24
|
+
- **`secedgar_get_institutional_holdings`' `ambiguous_entity` candidates carry SEC's ticker, split from the name** ([#236](https://github.com/cyanheads/secedgar-mcp-server/issues/236)).
|
|
25
|
+
- **The `resolvedAs` and `effectiveQuery` field descriptions** cover former tickers, earlier holders, and entity-index matches.
|
|
26
|
+
|
|
27
|
+
## Fixed
|
|
28
|
+
|
|
29
|
+
- **SEC's HTTP error response body no longer reaches callers in the error's `data`** (`body`, `responseBody`) ([#244](https://github.com/cyanheads/secedgar-mcp-server/issues/244)). It is attached to the error as its cause and written to the server's failure log; `status`, `url`, `retryAfter`, and the recovery hint stay.
|
|
30
|
+
- **`secedgar_company_search`'s text leaves out the SIC when SEC records none** ([#236](https://github.com/cyanheads/secedgar-mcp-server/issues/236)), common for a filer found only in EDGAR's entity index, instead of printing `SIC: ()`.
|
|
31
|
+
|
|
32
|
+
## Dependencies
|
|
33
|
+
|
|
34
|
+
- `better-sqlite3` ^13.0.3 → ^13.1.1
|
|
35
|
+
- `@biomejs/biome` ^2.6.6 → ^2.6.7 (dev)
|
|
@@ -43,7 +43,7 @@ export declare const companySearchTool: import("@cyanheads/mcp-ts-core").ToolDef
|
|
|
43
43
|
}, z.core.$strip>, readonly [{
|
|
44
44
|
readonly reason: "no_match";
|
|
45
45
|
readonly code: JsonRpcErrorCode.NotFound;
|
|
46
|
-
readonly when: "No company matches the query";
|
|
46
|
+
readonly when: "No company matches the query in SEC's ticker file, the former names it records, or EDGAR's entity index of every filer";
|
|
47
47
|
readonly recovery: "SEC's ticker index reflects the filer's own submissions record, which can differ from the exchange-listed symbol. ETFs and mutual funds resolve only by ticker (e.g. \"VOO\"); operating companies also resolve by full legal name or 10-digit CIK.";
|
|
48
48
|
}, {
|
|
49
49
|
readonly reason: "ambiguous_company";
|
|
@@ -71,6 +71,13 @@ export declare const companySearchTool: import("@cyanheads/mcp-ts-core").ToolDef
|
|
|
71
71
|
readonly recovery: 'Retry the same call in a minute — SEC EDGAR failed on its side, and nothing in the request needs to change.';
|
|
72
72
|
readonly retryable: true;
|
|
73
73
|
readonly thrownBy: 'service';
|
|
74
|
+
}, {
|
|
75
|
+
readonly reason: 'efts_degraded_response';
|
|
76
|
+
readonly code: JsonRpcErrorCode.ServiceUnavailable;
|
|
77
|
+
readonly when: 'EDGAR full-text search answered without results — its search backend failed to run the search on every attempt made (a connection or timeout failure, retried like a request SEC never answered), refused the request (upstreamErrorType and upstreamErrorMessage carry its error, and the request is not retried), or sent a payload with no hit list';
|
|
78
|
+
readonly recovery: 'Retry the same call in a minute unless the error is marked not retryable; then change the request as upstreamErrorMessage indicates.';
|
|
79
|
+
readonly retryable: true;
|
|
80
|
+
readonly thrownBy: 'service';
|
|
74
81
|
}], {
|
|
75
82
|
readonly notice: z.ZodOptional<z.ZodString>;
|
|
76
83
|
readonly truncated: z.ZodOptional<z.ZodBoolean>;
|
|
@@ -116,7 +123,7 @@ export declare function createCompanySearchTool(options: LimitClampOptions): imp
|
|
|
116
123
|
}, z.core.$strip>, readonly [{
|
|
117
124
|
readonly reason: "no_match";
|
|
118
125
|
readonly code: JsonRpcErrorCode.NotFound;
|
|
119
|
-
readonly when: "No company matches the query";
|
|
126
|
+
readonly when: "No company matches the query in SEC's ticker file, the former names it records, or EDGAR's entity index of every filer";
|
|
120
127
|
readonly recovery: "SEC's ticker index reflects the filer's own submissions record, which can differ from the exchange-listed symbol. ETFs and mutual funds resolve only by ticker (e.g. \"VOO\"); operating companies also resolve by full legal name or 10-digit CIK.";
|
|
121
128
|
}, {
|
|
122
129
|
readonly reason: "ambiguous_company";
|
|
@@ -144,6 +151,13 @@ export declare function createCompanySearchTool(options: LimitClampOptions): imp
|
|
|
144
151
|
readonly recovery: 'Retry the same call in a minute — SEC EDGAR failed on its side, and nothing in the request needs to change.';
|
|
145
152
|
readonly retryable: true;
|
|
146
153
|
readonly thrownBy: 'service';
|
|
154
|
+
}, {
|
|
155
|
+
readonly reason: 'efts_degraded_response';
|
|
156
|
+
readonly code: JsonRpcErrorCode.ServiceUnavailable;
|
|
157
|
+
readonly when: 'EDGAR full-text search answered without results — its search backend failed to run the search on every attempt made (a connection or timeout failure, retried like a request SEC never answered), refused the request (upstreamErrorType and upstreamErrorMessage carry its error, and the request is not retried), or sent a payload with no hit list';
|
|
158
|
+
readonly recovery: 'Retry the same call in a minute unless the error is marked not retryable; then change the request as upstreamErrorMessage indicates.';
|
|
159
|
+
readonly retryable: true;
|
|
160
|
+
readonly thrownBy: 'service';
|
|
147
161
|
}], {
|
|
148
162
|
readonly notice: z.ZodOptional<z.ZodString>;
|
|
149
163
|
readonly truncated: z.ZodOptional<z.ZodBoolean>;
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"company-search.tool.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/company-search.tool.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAQ,CAAC,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAY,MAAM,+BAA+B,CAAC;AAK3E,OAAO,EACL,KAAK,iBAAiB,EAGvB,MAAM,mCAAmC,CAAC;
|
|
1
|
+
{"version":3,"file":"company-search.tool.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/company-search.tool.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAQ,CAAC,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAY,MAAM,+BAA+B,CAAC;AAK3E,OAAO,EACL,KAAK,iBAAiB,EAGvB,MAAM,mCAAmC,CAAC;AAyN3C,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0f5B,CAAC;AAEH,+FAA+F;AAC/F,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAEjE"}
|