@cyanheads/openalex-mcp-server 0.8.0 → 0.10.0

package/dist/services/openalex/openalex-service.d.ts

@@ -4,6 +4,41 @@
  */
 import type { Context } from '@cyanheads/mcp-ts-core';
 import { type AnalyzeParams, type AnalyzeResult, type AutocompleteParams, type AutocompleteRecord, type AutocompleteResult, type EntityRecord, type EntityType, type SearchParams, type SearchResult } from './types.js';
+/** Whether this aggregation keeps count order, ignoring the native unknown-bucket suffix. */
+export declare function isBooleanGroupBy(groupBy: string): boolean;
+/** One upstream filter clause: the canonical key and the value it constrains. */
+type FilterClause = [key: string, value: string];
+/**
+ * Build an OpenAlex filter string from ordered key-value clauses.
+ * Input: [["cited_by_count", ">100"], ["is_oa", "true"]]
+ * Output: "cited_by_count:>100,is_oa:true"
+ *
+ * Clauses, not a record: OpenAlex ANDs a repeated key (`publication_year:2020,publication_year:2024`
+ * matches works in both years, which is nothing), and two caller filters can resolve to one
+ * canonical key. A record would hold only the last of them.
+ *
+ * Comma handling (commas collide with OpenAlex's filter clause separator):
+ * - Free-text search keys (`title.search`, `abstract.search.exact`, `semantic.search`, …) and
+ *   keys matched as whole text (`raw_affiliation_strings`, `display_name`, `geo.city`, …): the
+ *   value goes out double-quoted as `quotedCommaValue()` writes it, so the comma stays part of the
+ *   phrase. The quoted value is sent as written, `+` included.
+ * - All other keys: throw a pre-flight validation error — OpenAlex OR-lists use `|`, not commas.
+ *
+ * Every other value goes out as `upstreamFilterValue()` writes it: country and `language` values
+ * converted to the codes OpenAlex stores (a country segment that cannot be a code throws
+ * `invalid_country_code`), a multi-word value on a key matched as whole text (`geo.city`,
+ * `awards.funder_display_name`, …) double-quoted so OpenAlex reads it as one phrase, and the AND
+ * operator — a `+`, or a space on a key where words mean AND — sent as the AND it spells. A value
+ * that puts that operator beside a `|` throws `mixed_and_or_in_filter_value`, since OpenAlex drops
+ * every `|` alternative that ANDs more than one value; a value sent double-quoted that carries a
+ * `"` of its own throws `quote_in_filter_value`. A value left unquoted with an unmatched `"`
+ * throws `unmatched_quote_in_filter_value`. Every throw runs before any request.
+ * `autocomplete()` sends its filters without `translateFilters()`, so the conversion lives here
+ * rather than there.
+ *
+ * Exported for the timing suite, which runs it on caller-sized keys and values.
+ */
+export declare function buildFilterString(filters: FilterClause[]): string;
 /**
  * Recovery for a PMCID that reached OpenAlex and came back with nothing. OpenAlex indexes no
  * PMCIDs — `has_pmcid:true` matches zero works and a work's `ids` object never carries the key —
@@ -12,6 +47,11 @@ import { type AnalyzeParams, type AnalyzeResult, type AutocompleteParams, type A
  * mapping here and the `openalex_resolve_name` miss notice so both say the same thing.
  */
 export declare const PMCID_NOT_INDEXED_HINT = "OpenAlex indexes no PMCIDs, so a PMCID resolves nothing however it is written. Convert it to a PMID or DOI \u2014 the NCBI ID Converter (https://www.ncbi.nlm.nih.gov/pmc/tools/idconv/) does this \u2014 and retry with that identifier.";
+/**
+ * The filter clause that matches a funder by its bare DOI, or undefined for a value that clause
+ * would read as more than one literal DOI — it could only match some other funder, or every one.
+ */
+export declare function funderDoiFilter(doi: string): string | undefined;
 /**
  * Detect ID format and return the API path segment.
  * "10.1038/nature12373" → "doi:10.1038/nature12373"
@@ -25,18 +65,51 @@ export declare const PMCID_NOT_INDEXED_HINT = "OpenAlex indexes no PMCIDs, so a
  * "https://www.ncbi.nlm.nih.gov/pmc/articles/PMC1234567/" → "pmcid:PMC1234567"
  * "https://pubmed.ncbi.nlm.nih.gov/21491125" → "pmid:21491125"
  * "PMID:21491125" → "pmid:21491125"
- * "https://openalex.org/keywords/groundwater" → "groundwater"
+ * "https://openalex.org/works/W2741809807" → "W2741809807"
+ * "https://api.openalex.org/keywords/groundwater" → "groundwater"
  * "W2741809807" → "W2741809807"
  */
 export declare function normalizeId(id: string): string;
+/**
+ * The by-ID request path for `id`: `/<entityType>/<id>`, with every character a URL parse would
+ * read as structure percent-encoded so it stays part of the ID. OpenAlex decodes them back, so a
+ * DOI that holds a `#` or `?` reaches the record it names instead of a truncated one.
+ *
+ * A `.` or `..` segment, plain or percent-encoded, is refused before any request, since encoding
+ * cannot keep it inside the path. `/` is left as written, since DOIs carry it, and an encoded
+ * `%2F` is one segment to both the parse and OpenAlex. The refusal quotes `callerId`, the
+ * identifier as the caller wrote it, rather than the normalized `id` (`doi:…` for a DOI URL).
+ */
+export declare function byIdPath(entityType: EntityType, id: string, callerId?: string): string;
 /** An identifier the deterministic by-ID path can resolve, with the scheme it was read as. */
 export interface ResolvedIdentifier {
-    entityType: EntityType;
+    /** The entity types to look the identifier up as, in the order their records are returned. */
+    entityTypes: readonly EntityType[];
     /** The value in the form the OpenAlex path segment expects (`doi:10.1038/…`, `W2741809807`). */
     id: string;
+    /**
+     * Set on a bare native-ID shape, which short names share — keyword `p53` reads as publisher
+     * `P53`, and `F1`, `S1`, and `A1` are keywords too — so a lookup that finds no record is no
+     * sign the caller meant an ID, and the query is worth searching as a name next. A URL form
+     * names its record outright and never carries it.
+     */
+    mayBeName?: true;
     /** Identifier scheme, for caller-facing messages: `doi`, `orcid`, `openalex`, … */
     scheme: string;
 }
+/** What `resolveIdentifier()` found. */
+export interface IdentifierResolution extends AutocompleteResult {
+    /** Entity types whose lookup failed upstream while another type returned a record. */
+    failedEntityTypes?: EntityType[];
+    /**
+     * Set when every lookup found nothing and the query ran as a name search instead: `results`
+     * then hold that search's matches. `failedReason` names the upstream failure that stopped the
+     * search, with `results` empty.
+     */
+    nameFallback?: {
+        failedReason?: string;
+    };
+}
 /**
  * Classify a query as an identifier, or return `undefined` for a name.
  *
@@ -45,12 +118,17 @@ export interface ResolvedIdentifier {
  * it produced. Names never survive that: a name with a colon in it yields a prefix that is in no
  * scheme table, and anything else fails the native-ID pattern.
  *
- * Keywords are the exception, and are read from the raw query instead: their IDs are slugs, so
- * `normalizeId()` reduces the URL to a bare word that no longer names an entity type. The URL
- * form is the only keyword spelling that identifies itself — a bare slug is indistinguishable
- * from any other name, and autocomplete is the right answer for it.
+ * Keywords are the exception, and are read from the URL before it is reduced: their IDs are
+ * slugs, so `normalizeId()` turns the URL into a bare word that no longer names an entity type.
+ * The URL form is the only keyword spelling that identifies itself — a bare slug is
+ * indistinguishable from any other name, and autocomplete is the right answer for it.
+ *
+ * `requested` (the caller's `entity_type`) narrows an identifier only among the types it can
+ * address: a ROR to one of institutions, funders, and publishers, and a Funder Registry DOI to
+ * works. Any other type leaves the identifier's own types in place — except `keywords`, under
+ * which a bare native-ID shape is a name: keyword IDs are slugs, and `P53` is a keyword.
  */
-export declare function inferIdentifier(query: string): ResolvedIdentifier | undefined;
+export declare function inferIdentifier(query: string, requested?: EntityType): ResolvedIdentifier | undefined;
 /**
  * Shape a singleton entity record like an autocomplete match, so both resolution paths of
  * `openalex_resolve_name` return one result type. `entity_type` is singularized to match what
@@ -59,11 +137,27 @@ export declare function inferIdentifier(query: string): ResolvedIdentifier | und
  */
 export declare function toAutocompleteRecord(entityType: EntityType, record: EntityRecord): AutocompleteRecord;
 /**
- * The upstream field one caller-supplied `select` name projects to — `authors` → `authorships`
- * on works, `h_index` → `summary_stats` where that object exists; any other name unchanged.
- * Exported so a tool can find the record key a one-field projection lands under.
+ * The works `select` field the server derives rather than projects: each authorship's author as
+ * `{id, display_name, orcid}`, from the `authorships` it requests in its place. Not an upstream
+ * field, so it is never forwarded, and neither the default projection nor `*` includes it.
  */
-export declare function translateSelectField(entityType: SearchParams['entityType'], field: string): string;
+export declare const AUTHOR_LIST_FIELD = "author_list";
+/**
+ * The record key one caller-supplied `select` name lands under: `author_list` keeps its own
+ * name; any other name lands under the upstream field it projects (`authors` → `authorships`).
+ * Exported so a tool can find the array a one-field projection returns.
+ */
+export declare function selectRecordKey(entityType: SearchParams['entityType'], field: string): string;
+/**
+ * Detect a value the `id:` filter would carry — OpenAlex IDs, bare or in any URL spelling
+ * `parseOpenAlexUrl()` reads, optionally pipe-joined for OR semantics. When matched, `id` is
+ * rewritten to `openalex` (the canonical filter key) and the value is forwarded as written:
+ * upstream accepts every one of those spellings, and the space around a `|`. Stricter than any
+ * value so a future generic upstream `id:` filter wouldn't be shadowed — only values that read
+ * as OpenAlex IDs get redirected. Exported for the timing suite, which runs it on caller-sized
+ * values.
+ */
+export declare function isOpenAlexFilterValue(value: string): boolean;
 /**
  * Rewrite one caller-supplied filter key to the upstream OpenAlex name, before the
  * value-dependent `id` rewrite. Exported so the citation-graph tool can check a caller's key
@@ -74,6 +168,21 @@ export declare function translateSelectField(entityType: SearchParams['entityTyp
  * typos no map can preempt.
  */
 export declare function translateFilterKey(entityType: SearchParams['entityType'], key: string): string;
+/**
+ * The `filter` parameter a search or group_by over `filters` sends: keys translated, then each
+ * clause built by `buildFilterString()`, whose pre-flight throws (`comma_in_filter_value`,
+ * `invalid_country_code`, `mixed_and_or_in_filter_value`, `quote_in_filter_value`,
+ * `unmatched_quote_in_filter_value`) it shares.
+ * Exported so a tool that spends a request before its search — the citation graph's seed lookup —
+ * can run those checks first and fail without one.
+ */
+export declare function buildSearchFilter(entityType: SearchParams['entityType'], filters: Record<string, string>): string;
+/**
+ * Recovery for every `upstream_unavailable` failure of a semantic search — a relabelled embedding
+ * failure, the 503 OpenAlex sends when the embedding timed out, or any other outage — since a
+ * keyword search does not depend on the embedding service and can answer while it is down.
+ */
+export declare const SEMANTIC_UNAVAILABLE_HINT = "OpenAlex semantic search is failing upstream. Retry in a minute, or rerun with search_mode \"keyword\", which does not depend on it.";
 /**
  * Recovery for a spent daily budget on a server that sends no API key. It runs on the smaller
  * anonymous budget, so a key is the one fix besides waiting. A keyed server's budget is already
@@ -81,21 +190,40 @@ export declare function translateFilterKey(entityType: SearchParams['entityType'
  * case keeps the key-neutral recovery each tool's contract declares.
  */
 export declare const BUDGET_EXHAUSTED_KEYLESS_HINT = "This server's daily OpenAlex budget is spent and refills at midnight UTC \u2014 retrying before then will not succeed. The server sends no OpenAlex API key, so it runs on the smaller anonymous budget; setting OPENALEX_API_KEY to a free key (https://openalex.org/settings/api) raises it.";
+/**
+ * The server's own message for a plan-gated filter, naming the filter when the upstream message
+ * opens with it. The name is read as a field-name run only, so caller text the upstream clause
+ * echoes cannot carry markdown or a line break into the message.
+ */
+export declare function planGatedFilterMessage(upstreamMessage: string | undefined): string;
 declare class OpenAlexService {
     private readonly baseUrl;
     private readonly apiKey;
     private readonly mailto;
     constructor();
-    /** Execute an HTTP request against the OpenAlex API with retry on transient failures. */
+    /**
+     * Execute an HTTP request against the OpenAlex API with retry on transient failures. With
+     * `deadlineMs`, every attempt and backoff settles within that many milliseconds, after which
+     * the request fails as a `Timeout`.
+     */
     private request;
     private throwNormalizedRequestError;
     private parseResponse;
     /** Search/filter/sort entities, or retrieve a single entity by ID. */
     search(params: SearchParams, ctx: Context): Promise<SearchResult>;
+    /**
+     * Look a funder up by its Crossref Funder Registry DOI. OpenAlex's `/funders/doi:` path
+     * resolves nothing, so this is a one-result list request on the `ids.doi` filter, which OpenAlex
+     * bills like any list request. A value the filter would read as more than one literal DOI fails
+     * as not found without a request (see `funderDoiFilter`).
+     */
+    private funderByDoi;
     /** Group-by aggregation. */
     analyze(params: AnalyzeParams, ctx: Context): Promise<AnalyzeResult>;
     /**
-     * Resolve an identifier to the single entity it addresses, shaped as an autocomplete match.
+     * Resolve an identifier to the entities it addresses, shaped as autocomplete matches — one
+     * lookup per entity type in `identifier.entityTypes`, run in parallel, with the records found
+     * returned in that order.
      *
      * Autocomplete matches on `display_name` and the external-ID URL, so whether an identifier
      * resolves through it depends on scheme, bare-vs-URL form, and entity type — a bare ORCID or
@@ -106,22 +234,50 @@ declare class OpenAlexService {
      * A miss returns no results rather than throwing. Autocomplete answers an unmatched query with
      * an empty list, and routing identifiers through here is meant to make them behave *more* like
      * the front door, not to hand one class of query a hard failure the rest never sees.
+     *
+     * A lookup that fails for any other reason drops only its own type, named in
+     * `failedEntityTypes`, while another type returned a record. With no record to return, or once
+     * the caller has cancelled, the failure is thrown instead — an empty or partial answer there
+     * would claim records do not exist when the lookup for them never finished.
+     *
+     * `nameSearch` is the autocomplete to run when every lookup finds nothing — for a query that
+     * may be a name rather than an ID (`ResolvedIdentifier.mayBeName`). It runs only on that miss,
+     * so an ID that resolves still costs its one request, and only within what is left of
+     * `NAME_FALLBACK_DEADLINE_MS` from the start of this call (see `nameSearchAfterMiss`).
+     *
+     * `query` is the text `identifier` was read from, as the caller wrote it. The lookups are sent
+     * that spelling, which `search()` normalizes back to `identifier.id`, so a lookup that refuses
+     * the identifier quotes what the caller sent.
+     */
+    resolveIdentifier(identifier: ResolvedIdentifier, ctx: Context, nameSearch?: AutocompleteParams, query?: string): Promise<IdentifierResolution>;
+    /**
+     * The name search an identifier lookup falls back to after finding nothing, bounded by the
+     * `remainingMs` the lookup left of the call's deadline. It is a best-effort second reading of
+     * the query, so a transient upstream failure — a timeout, the deadline running out, an outage,
+     * a burst throttle — comes back as `nameFallback.failedReason` for the caller to see, beside
+     * the lookup's own true miss. A caller cancellation, a request upstream rejected, a spent
+     * budget, and anything unclassified are thrown: none of them is cured by calling again, and an
+     * answer in their place would hide the error the caller needs to act on.
      */
-    resolveIdentifier(identifier: ResolvedIdentifier, ctx: Context): Promise<AutocompleteResult>;
-    /** Autocomplete name resolution. */
-    autocomplete(params: AutocompleteParams, ctx: Context): Promise<AutocompleteResult>;
+    private nameSearchAfterMiss;
+    /**
+     * Autocomplete name resolution. `deadlineMs` bounds the whole request, retries included (see
+     * `request`).
+     */
+    autocomplete(params: AutocompleteParams, ctx: Context, deadlineMs?: number): Promise<AutocompleteResult>;
 }
 export declare function initOpenAlexService(): void;
 export declare function getOpenAlexService(): OpenAlexService;
+type FieldCatalog = Record<EntityType, {
+    filter: string[];
+    select: string[];
+}>;
 /**
  * Return the typed field catalog keyed by entity type → context → field list.
  * Only `filter` and `select` arrays are stored. `group_by` resolves to the `filter` key here;
  * the describe-fields handler then prunes the fields group_by cannot target (raw dates,
  * `*.search` operators, `from_*`/`to_*` range modifiers, and a per-type set from a live sweep).
  */
-export declare function getFieldCatalog(): Record<EntityType, {
-    filter: string[];
-    select: string[];
-}>;
+export declare function getFieldCatalog(): FieldCatalog;
 export {};
 //# sourceMappingURL=openalex-service.d.ts.map

package/dist/services/openalex/openalex-service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openalex-service.d.ts","sourceRoot":"","sources":["../../../src/services/openalex/openalex-service.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAuBtD,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EAGvB,KAAK,YAAY,EACjB,KAAK,UAAU,EAEf,KAAK,YAAY,EACjB,KAAK,YAAY,EAClB,MAAM,YAAY,CAAC;AAoFpB;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,8OACgM,CAAC;AA0BpO;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAuF9C;AAuBD,8FAA8F;AAC9F,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,UAAU,CAAC;IACvB,gGAAgG;IAChG,EAAE,EAAE,MAAM,CAAC;IACX,mFAAmF;IACnF,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS,CAkB7E;AA4HD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,YAAY,GACnB,kBAAkB,CAUpB;AA2ED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,YAAY,CAAC,YAAY,CAAC,EACtC,KAAK,EAAE,MAAM,GACZ,MAAM,CAQR;AA+CD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,YAAY,CAAC,YAAY,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAE9F;AAqSD;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,mSACmP,CAAC;AAsJ9R,cAAM,eAAe;IACnB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAEhC,cAKC;IAED,yFAAyF;IACzF,OAAO,CAAC,OAAO;IAgDf,OAAO,CAAC,2BAA2B;IAgGnC,OAAO,CAAC,aAAa;IAqCrB,sEAAsE;IAChE,MAAM,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,YAAY,CAAC,CA6FtE;IAED,4BAA4B;IACtB,OAAO,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,aAAa,CAAC,CA2DzE;IAED;;;;;;;;;;;;OAYG;IACG,iBAAiB,CACrB,UAAU,EAAE,kBAAkB,EAC9B,GAAG,EAAE,OAAO,GACX,OAAO,CAAC,kBAAkB,CAAC,CAkB7B;IAED,oCAAoC;IAC9B,YAAY,CAAC,MAAM,EAAE,kBAAkB,EAAE,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAsBxF;CACF;AAID,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C;AAED,wBAAgB,kBAAkB,IAAI,eAAe,CAIpD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAAC,UAAU,EAAE;IAAE,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAE5F"}
+{"version":3,"file":"openalex-service.d.ts","sourceRoot":"","sources":["../../../src/services/openalex/openalex-service.ts"],"names":[],"mappings":"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"}