@cyanheads/cern-inspire-mcp-server 0.2.0 → 0.3.0
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 +11 -9
- package/CLAUDE.md +11 -9
- package/README.md +22 -13
- package/changelog/0.3.x/0.3.0.md +31 -0
- package/changelog/template.md +10 -3
- package/dist/index.js +1 -1
- package/dist/index.js.map +1 -1
- package/dist/mcp-server/resources/definitions/index.d.ts +20 -0
- package/dist/mcp-server/resources/definitions/index.d.ts.map +1 -1
- package/dist/mcp-server/resources/definitions/inspire-literature.resource.d.ts +20 -0
- package/dist/mcp-server/resources/definitions/inspire-literature.resource.d.ts.map +1 -1
- package/dist/mcp-server/resources/definitions/inspire-literature.resource.js +1 -1
- package/dist/mcp-server/resources/definitions/inspire-literature.resource.js.map +1 -1
- package/dist/mcp-server/tools/definitions/export-citations.tool.d.ts.map +1 -1
- package/dist/mcp-server/tools/definitions/export-citations.tool.js +12 -14
- package/dist/mcp-server/tools/definitions/export-citations.tool.js.map +1 -1
- package/dist/mcp-server/tools/definitions/get-citation-summary.tool.d.ts.map +1 -1
- package/dist/mcp-server/tools/definitions/get-citation-summary.tool.js +8 -10
- package/dist/mcp-server/tools/definitions/get-citation-summary.tool.js.map +1 -1
- package/dist/mcp-server/tools/definitions/get-paper.tool.d.ts +45 -3
- package/dist/mcp-server/tools/definitions/get-paper.tool.d.ts.map +1 -1
- package/dist/mcp-server/tools/definitions/get-paper.tool.js +92 -27
- package/dist/mcp-server/tools/definitions/get-paper.tool.js.map +1 -1
- package/dist/mcp-server/tools/definitions/index.d.ts +248 -140
- package/dist/mcp-server/tools/definitions/index.d.ts.map +1 -1
- package/dist/mcp-server/tools/definitions/index.js +2 -0
- package/dist/mcp-server/tools/definitions/index.js.map +1 -1
- package/dist/mcp-server/tools/definitions/list-reference.tool.d.ts.map +1 -1
- package/dist/mcp-server/tools/definitions/list-reference.tool.js +19 -9
- package/dist/mcp-server/tools/definitions/list-reference.tool.js.map +1 -1
- package/dist/mcp-server/tools/definitions/search-authors.tool.d.ts +17 -5
- package/dist/mcp-server/tools/definitions/search-authors.tool.d.ts.map +1 -1
- package/dist/mcp-server/tools/definitions/search-authors.tool.js +63 -23
- package/dist/mcp-server/tools/definitions/search-authors.tool.js.map +1 -1
- package/dist/mcp-server/tools/definitions/search-experiments.tool.d.ts +16 -5
- package/dist/mcp-server/tools/definitions/search-experiments.tool.d.ts.map +1 -1
- package/dist/mcp-server/tools/definitions/search-experiments.tool.js +62 -25
- package/dist/mcp-server/tools/definitions/search-experiments.tool.js.map +1 -1
- package/dist/mcp-server/tools/definitions/search-hepdata.tool.d.ts +2 -2
- package/dist/mcp-server/tools/definitions/search-hepdata.tool.d.ts.map +1 -1
- package/dist/mcp-server/tools/definitions/search-hepdata.tool.js +11 -9
- package/dist/mcp-server/tools/definitions/search-hepdata.tool.js.map +1 -1
- package/dist/mcp-server/tools/definitions/search-institutions.tool.d.ts +77 -0
- package/dist/mcp-server/tools/definitions/search-institutions.tool.d.ts.map +1 -0
- package/dist/mcp-server/tools/definitions/search-institutions.tool.js +228 -0
- package/dist/mcp-server/tools/definitions/search-institutions.tool.js.map +1 -0
- package/dist/mcp-server/tools/definitions/search-literature.tool.d.ts.map +1 -1
- package/dist/mcp-server/tools/definitions/search-literature.tool.js +13 -14
- package/dist/mcp-server/tools/definitions/search-literature.tool.js.map +1 -1
- package/dist/mcp-server/tools/inputs.d.ts +33 -3
- package/dist/mcp-server/tools/inputs.d.ts.map +1 -1
- package/dist/mcp-server/tools/inputs.js +187 -4
- package/dist/mcp-server/tools/inputs.js.map +1 -1
- package/dist/services/http/fetch-bounded.d.ts +1 -1
- package/dist/services/http/fetch-bounded.js +1 -1
- package/dist/services/inspire/identifiers.d.ts +20 -6
- package/dist/services/inspire/identifiers.d.ts.map +1 -1
- package/dist/services/inspire/identifiers.js +30 -9
- package/dist/services/inspire/identifiers.js.map +1 -1
- package/dist/services/inspire/inspire-service.d.ts +17 -7
- package/dist/services/inspire/inspire-service.d.ts.map +1 -1
- package/dist/services/inspire/inspire-service.js +67 -13
- package/dist/services/inspire/inspire-service.js.map +1 -1
- package/dist/services/inspire/normalize.d.ts +10 -2
- package/dist/services/inspire/normalize.d.ts.map +1 -1
- package/dist/services/inspire/normalize.js +69 -1
- package/dist/services/inspire/normalize.js.map +1 -1
- package/dist/services/inspire/types.d.ts +115 -0
- package/dist/services/inspire/types.d.ts.map +1 -1
- package/package.json +8 -8
- package/server.json +3 -3
- package/skills/cern-inspire-guide/SKILL.md +8 -8
|
@@ -3,6 +3,194 @@
|
|
|
3
3
|
* @module mcp-server/tools/definitions
|
|
4
4
|
*/
|
|
5
5
|
export declare const allToolDefinitions: (import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
|
|
6
|
+
query: import("zod").ZodString;
|
|
7
|
+
format: import("zod").ZodPreprocess<import("zod").ZodDefault<import("zod").ZodEnum<{
|
|
8
|
+
bibtex: "bibtex";
|
|
9
|
+
"latex-eu": "latex-eu";
|
|
10
|
+
"latex-us": "latex-us";
|
|
11
|
+
}>>, unknown>;
|
|
12
|
+
document_types: import("zod").ZodPreprocess<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
|
|
13
|
+
"activity report": "activity report";
|
|
14
|
+
article: "article";
|
|
15
|
+
book: "book";
|
|
16
|
+
"book chapter": "book chapter";
|
|
17
|
+
"conference paper": "conference paper";
|
|
18
|
+
introductory: "introductory";
|
|
19
|
+
lectures: "lectures";
|
|
20
|
+
note: "note";
|
|
21
|
+
proceedings: "proceedings";
|
|
22
|
+
published: "published";
|
|
23
|
+
report: "report";
|
|
24
|
+
review: "review";
|
|
25
|
+
thesis: "thesis";
|
|
26
|
+
}>>>, unknown>;
|
|
27
|
+
subjects: import("zod").ZodPreprocess<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
|
|
28
|
+
Accelerators: "Accelerators";
|
|
29
|
+
Astrophysics: "Astrophysics";
|
|
30
|
+
Computing: "Computing";
|
|
31
|
+
"Condensed Matter": "Condensed Matter";
|
|
32
|
+
"Data Analysis and Statistics": "Data Analysis and Statistics";
|
|
33
|
+
"Experiment-HEP": "Experiment-HEP";
|
|
34
|
+
"Experiment-Nucl": "Experiment-Nucl";
|
|
35
|
+
"General Physics": "General Physics";
|
|
36
|
+
"Gravitation and Cosmology": "Gravitation and Cosmology";
|
|
37
|
+
Instrumentation: "Instrumentation";
|
|
38
|
+
Lattice: "Lattice";
|
|
39
|
+
"Math and Math Physics": "Math and Math Physics";
|
|
40
|
+
Other: "Other";
|
|
41
|
+
"Phenomenology-HEP": "Phenomenology-HEP";
|
|
42
|
+
"Quantum Physics": "Quantum Physics";
|
|
43
|
+
"Theory-HEP": "Theory-HEP";
|
|
44
|
+
"Theory-Nucl": "Theory-Nucl";
|
|
45
|
+
Unknown: "Unknown";
|
|
46
|
+
}>>>, unknown>;
|
|
47
|
+
year_from: import("zod").ZodPreprocess<import("zod").ZodOptional<import("zod").ZodNumber>, unknown>;
|
|
48
|
+
year_to: import("zod").ZodPreprocess<import("zod").ZodOptional<import("zod").ZodNumber>, unknown>;
|
|
49
|
+
sort: import("zod").ZodPreprocess<import("zod").ZodDefault<import("zod").ZodEnum<{
|
|
50
|
+
mostcited: "mostcited";
|
|
51
|
+
mostrecent: "mostrecent";
|
|
52
|
+
relevance: "relevance";
|
|
53
|
+
}>>, unknown>;
|
|
54
|
+
page: import("zod").ZodPreprocess<import("zod").ZodDefault<import("zod").ZodNumber>, unknown>;
|
|
55
|
+
size: import("zod").ZodPreprocess<import("zod").ZodDefault<import("zod").ZodNumber>, unknown>;
|
|
56
|
+
}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
|
|
57
|
+
format: import("zod").ZodEnum<{
|
|
58
|
+
bibtex: "bibtex";
|
|
59
|
+
"latex-eu": "latex-eu";
|
|
60
|
+
"latex-us": "latex-us";
|
|
61
|
+
}>;
|
|
62
|
+
page: import("zod").ZodNumber;
|
|
63
|
+
entries: import("zod").ZodArray<import("zod").ZodObject<{
|
|
64
|
+
texkey: import("zod").ZodString;
|
|
65
|
+
text: import("zod").ZodString;
|
|
66
|
+
}, import("zod/v4/core").$strip>>;
|
|
67
|
+
}, import("zod/v4/core").$strip>, readonly [{
|
|
68
|
+
readonly reason: "invalid_year_range";
|
|
69
|
+
readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
|
|
70
|
+
readonly when: "year_from is later than year_to.";
|
|
71
|
+
readonly recovery: "Swap year_from and year_to so the range runs forward, or drop one bound for an open range, then retry this call.";
|
|
72
|
+
readonly severity: "notice";
|
|
73
|
+
}, {
|
|
74
|
+
readonly reason: "beyond_result_window";
|
|
75
|
+
readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
|
|
76
|
+
readonly when: "page × effective size (after clamping) exceeds the 10,000 results INSPIRE serves for one query.";
|
|
77
|
+
readonly recovery: "Narrow the query with tighter terms, such as a date range (\"and date > 2015\") or a collaboration, until it matches under 10,000 papers, then page again with cern_inspire_export_citations.";
|
|
78
|
+
readonly severity: "notice";
|
|
79
|
+
}, {
|
|
80
|
+
readonly reason: "invalid_query";
|
|
81
|
+
readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
|
|
82
|
+
readonly when: "A recognized field clause has no value, or INSPIRE answered 400 to a parameter value it refuses.";
|
|
83
|
+
readonly recovery: "Give every field a value (for example \"a Witten\"), check cern_inspire_list_reference topic search_syntax, then retry cern_inspire_export_citations.";
|
|
84
|
+
readonly severity: "notice";
|
|
85
|
+
readonly thrownBy: "service";
|
|
86
|
+
}, {
|
|
87
|
+
readonly reason: "inspire_rate_limited";
|
|
88
|
+
readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.RateLimited;
|
|
89
|
+
readonly when: "INSPIRE returned 429 after the pacer and retries.";
|
|
90
|
+
readonly recovery: "Wait the retry-after seconds this error states (at least 5), then retry this call; INSPIRE allows 15 requests per 5 seconds from one address.";
|
|
91
|
+
readonly retryable: true;
|
|
92
|
+
readonly thrownBy: "service";
|
|
93
|
+
}, {
|
|
94
|
+
readonly reason: "pacer_shed";
|
|
95
|
+
readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.RateLimited;
|
|
96
|
+
readonly when: "The server's outbound INSPIRE queue could not start the request within the call's remaining budget.";
|
|
97
|
+
readonly recovery: "This server's INSPIRE request queue is saturated; wait the seconds in this error's retryAfter field (about 5 when it is not shown), then retry this call with fewer cern_inspire calls running in parallel.";
|
|
98
|
+
readonly retryable: true;
|
|
99
|
+
readonly thrownBy: "service";
|
|
100
|
+
}, {
|
|
101
|
+
readonly reason: "upstream_unreadable";
|
|
102
|
+
readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ServiceUnavailable;
|
|
103
|
+
readonly when: "The INSPIRE body exceeded the byte ceiling, the citation page was JSON or HTML instead of citation text, or selection verification returned unreadable JSON.";
|
|
104
|
+
readonly recovery: "Retry this call in a few seconds; if it fails again, INSPIRE is likely serving an error page, so wait a minute before retrying cern_inspire_export_citations with the same page and size.";
|
|
105
|
+
readonly thrownBy: "service";
|
|
106
|
+
}], {
|
|
107
|
+
readonly appliedFilters: import("zod").ZodString;
|
|
108
|
+
readonly truncated: import("zod").ZodBoolean;
|
|
109
|
+
readonly shown: import("zod").ZodNumber;
|
|
110
|
+
readonly cap: import("zod").ZodNumber;
|
|
111
|
+
readonly nextPage: import("zod").ZodOptional<import("zod").ZodNumber>;
|
|
112
|
+
readonly notice: import("zod").ZodOptional<import("zod").ZodString>;
|
|
113
|
+
}> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
|
|
114
|
+
query: import("zod").ZodString;
|
|
115
|
+
page: import("zod").ZodPreprocess<import("zod").ZodDefault<import("zod").ZodNumber>, unknown>;
|
|
116
|
+
limit: import("zod").ZodPreprocess<import("zod").ZodDefault<import("zod").ZodNumber>, unknown>;
|
|
117
|
+
}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
|
|
118
|
+
experiments: import("zod").ZodArray<import("zod").ZodObject<{
|
|
119
|
+
recid: import("zod").ZodString;
|
|
120
|
+
legacyName: import("zod").ZodString;
|
|
121
|
+
name: import("zod").ZodOptional<import("zod").ZodString>;
|
|
122
|
+
shortName: import("zod").ZodOptional<import("zod").ZodString>;
|
|
123
|
+
longName: import("zod").ZodOptional<import("zod").ZodString>;
|
|
124
|
+
accelerator: import("zod").ZodOptional<import("zod").ZodString>;
|
|
125
|
+
institutions: import("zod").ZodArray<import("zod").ZodObject<{
|
|
126
|
+
name: import("zod").ZodString;
|
|
127
|
+
recid: import("zod").ZodOptional<import("zod").ZodString>;
|
|
128
|
+
}, import("zod/v4/core").$strip>>;
|
|
129
|
+
collaboration: import("zod").ZodOptional<import("zod").ZodObject<{
|
|
130
|
+
name: import("zod").ZodString;
|
|
131
|
+
subgroups: import("zod").ZodArray<import("zod").ZodString>;
|
|
132
|
+
}, import("zod/v4/core").$strip>>;
|
|
133
|
+
classification: import("zod").ZodArray<import("zod").ZodString>;
|
|
134
|
+
projectTypes: import("zod").ZodArray<import("zod").ZodString>;
|
|
135
|
+
dateProposed: import("zod").ZodOptional<import("zod").ZodString>;
|
|
136
|
+
dateApproved: import("zod").ZodOptional<import("zod").ZodString>;
|
|
137
|
+
dateStarted: import("zod").ZodOptional<import("zod").ZodString>;
|
|
138
|
+
dateCompleted: import("zod").ZodOptional<import("zod").ZodString>;
|
|
139
|
+
ongoing: import("zod").ZodOptional<import("zod").ZodBoolean>;
|
|
140
|
+
numberOfPapers: import("zod").ZodOptional<import("zod").ZodNumber>;
|
|
141
|
+
description: import("zod").ZodOptional<import("zod").ZodString>;
|
|
142
|
+
urls: import("zod").ZodArray<import("zod").ZodObject<{
|
|
143
|
+
url: import("zod").ZodString;
|
|
144
|
+
description: import("zod").ZodOptional<import("zod").ZodString>;
|
|
145
|
+
}, import("zod/v4/core").$strip>>;
|
|
146
|
+
nameVariants: import("zod").ZodArray<import("zod").ZodString>;
|
|
147
|
+
core: import("zod").ZodOptional<import("zod").ZodBoolean>;
|
|
148
|
+
literatureQuery: import("zod").ZodOptional<import("zod").ZodString>;
|
|
149
|
+
}, import("zod/v4/core").$strip>>;
|
|
150
|
+
page: import("zod").ZodNumber;
|
|
151
|
+
limit: import("zod").ZodNumber;
|
|
152
|
+
hasMore: import("zod").ZodBoolean;
|
|
153
|
+
}, import("zod/v4/core").$strip>, readonly [{
|
|
154
|
+
readonly reason: "beyond_result_window";
|
|
155
|
+
readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
|
|
156
|
+
readonly when: "page × effective limit (after clamping) exceeds the 10,000 results INSPIRE serves for one query.";
|
|
157
|
+
readonly recovery: "Narrow the query with a more specific name, legacy name, or accelerator until it matches under 10,000 records, then page again with cern_inspire_search_experiments.";
|
|
158
|
+
readonly severity: "notice";
|
|
159
|
+
}, {
|
|
160
|
+
readonly reason: "invalid_query";
|
|
161
|
+
readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
|
|
162
|
+
readonly when: "INSPIRE answered 400 to a parameter value it refuses.";
|
|
163
|
+
readonly recovery: "Retry cern_inspire_search_experiments with a plain experiment, collaboration, or accelerator name.";
|
|
164
|
+
readonly severity: "notice";
|
|
165
|
+
readonly thrownBy: "service";
|
|
166
|
+
}, {
|
|
167
|
+
readonly reason: "inspire_rate_limited";
|
|
168
|
+
readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.RateLimited;
|
|
169
|
+
readonly when: "INSPIRE returned 429 after the pacer and retries.";
|
|
170
|
+
readonly recovery: "Wait the retry-after seconds this error states (at least 5), then retry this call; INSPIRE allows 15 requests per 5 seconds from one address.";
|
|
171
|
+
readonly retryable: true;
|
|
172
|
+
readonly thrownBy: "service";
|
|
173
|
+
}, {
|
|
174
|
+
readonly reason: "pacer_shed";
|
|
175
|
+
readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.RateLimited;
|
|
176
|
+
readonly when: "The server's outbound INSPIRE queue could not start the request within the call's remaining budget.";
|
|
177
|
+
readonly recovery: "This server's INSPIRE request queue is saturated; wait the seconds in this error's retryAfter field (about 5 when it is not shown), then retry this call with fewer cern_inspire calls running in parallel.";
|
|
178
|
+
readonly retryable: true;
|
|
179
|
+
readonly thrownBy: "service";
|
|
180
|
+
}, {
|
|
181
|
+
readonly reason: "upstream_unreadable";
|
|
182
|
+
readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ServiceUnavailable;
|
|
183
|
+
readonly when: "The INSPIRE body exceeded the byte ceiling, was HTML where JSON was expected, or was invalid JSON.";
|
|
184
|
+
readonly recovery: "Retry this call in a few seconds; if it fails again, INSPIRE is likely serving an error page, so wait a minute before retrying cern_inspire_search_experiments with the same page and limit.";
|
|
185
|
+
readonly thrownBy: "service";
|
|
186
|
+
}], {
|
|
187
|
+
readonly totalCount: import("zod").ZodNumber;
|
|
188
|
+
readonly truncated: import("zod").ZodBoolean;
|
|
189
|
+
readonly shown: import("zod").ZodNumber;
|
|
190
|
+
readonly cap: import("zod").ZodNumber;
|
|
191
|
+
readonly nextPage: import("zod").ZodOptional<import("zod").ZodNumber>;
|
|
192
|
+
readonly notice: import("zod").ZodOptional<import("zod").ZodString>;
|
|
193
|
+
}> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
|
|
6
194
|
query: import("zod").ZodString;
|
|
7
195
|
sort: import("zod").ZodPreprocess<import("zod").ZodDefault<import("zod").ZodEnum<{
|
|
8
196
|
mostcited: "mostcited";
|
|
@@ -146,6 +334,14 @@ export declare const allToolDefinitions: (import("@cyanheads/mcp-ts-core").ToolD
|
|
|
146
334
|
orcid: import("zod").ZodOptional<import("zod").ZodString>;
|
|
147
335
|
affiliations: import("zod").ZodArray<import("zod").ZodString>;
|
|
148
336
|
}, import("zod/v4/core").$strip>>;
|
|
337
|
+
supervisors: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
|
|
338
|
+
name: import("zod").ZodString;
|
|
339
|
+
roles: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
|
|
340
|
+
recid: import("zod").ZodOptional<import("zod").ZodString>;
|
|
341
|
+
bai: import("zod").ZodOptional<import("zod").ZodString>;
|
|
342
|
+
orcid: import("zod").ZodOptional<import("zod").ZodString>;
|
|
343
|
+
affiliations: import("zod").ZodArray<import("zod").ZodString>;
|
|
344
|
+
}, import("zod/v4/core").$strip>>>;
|
|
149
345
|
collaborations: import("zod").ZodArray<import("zod").ZodString>;
|
|
150
346
|
experiments: import("zod").ZodArray<import("zod").ZodObject<{
|
|
151
347
|
name: import("zod").ZodString;
|
|
@@ -161,6 +357,18 @@ export declare const allToolDefinitions: (import("@cyanheads/mcp-ts-core").ToolD
|
|
|
161
357
|
pages: import("zod").ZodOptional<import("zod").ZodString>;
|
|
162
358
|
articleId: import("zod").ZodOptional<import("zod").ZodString>;
|
|
163
359
|
freetext: import("zod").ZodOptional<import("zod").ZodString>;
|
|
360
|
+
cnum: import("zod").ZodOptional<import("zod").ZodString>;
|
|
361
|
+
conferenceRecid: import("zod").ZodOptional<import("zod").ZodString>;
|
|
362
|
+
parentRecid: import("zod").ZodOptional<import("zod").ZodString>;
|
|
363
|
+
}, import("zod/v4/core").$strip>>;
|
|
364
|
+
thesis: import("zod").ZodOptional<import("zod").ZodObject<{
|
|
365
|
+
degreeType: import("zod").ZodOptional<import("zod").ZodString>;
|
|
366
|
+
institutions: import("zod").ZodArray<import("zod").ZodObject<{
|
|
367
|
+
name: import("zod").ZodString;
|
|
368
|
+
recid: import("zod").ZodOptional<import("zod").ZodString>;
|
|
369
|
+
}, import("zod/v4/core").$strip>>;
|
|
370
|
+
defenseDate: import("zod").ZodOptional<import("zod").ZodString>;
|
|
371
|
+
date: import("zod").ZodOptional<import("zod").ZodString>;
|
|
164
372
|
}, import("zod/v4/core").$strip>>;
|
|
165
373
|
arxivId: import("zod").ZodOptional<import("zod").ZodString>;
|
|
166
374
|
arxivCategories: import("zod").ZodArray<import("zod").ZodString>;
|
|
@@ -245,116 +453,9 @@ export declare const allToolDefinitions: (import("@cyanheads/mcp-ts-core").ToolD
|
|
|
245
453
|
readonly shown: import("zod").ZodNumber;
|
|
246
454
|
readonly cap: import("zod").ZodNumber;
|
|
247
455
|
readonly notice: import("zod").ZodOptional<import("zod").ZodString>;
|
|
248
|
-
}> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
|
|
249
|
-
query: import("zod").ZodString;
|
|
250
|
-
format: import("zod").ZodPreprocess<import("zod").ZodDefault<import("zod").ZodEnum<{
|
|
251
|
-
bibtex: "bibtex";
|
|
252
|
-
"latex-eu": "latex-eu";
|
|
253
|
-
"latex-us": "latex-us";
|
|
254
|
-
}>>, unknown>;
|
|
255
|
-
document_types: import("zod").ZodPreprocess<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
|
|
256
|
-
"activity report": "activity report";
|
|
257
|
-
article: "article";
|
|
258
|
-
book: "book";
|
|
259
|
-
"book chapter": "book chapter";
|
|
260
|
-
"conference paper": "conference paper";
|
|
261
|
-
introductory: "introductory";
|
|
262
|
-
lectures: "lectures";
|
|
263
|
-
note: "note";
|
|
264
|
-
proceedings: "proceedings";
|
|
265
|
-
published: "published";
|
|
266
|
-
report: "report";
|
|
267
|
-
review: "review";
|
|
268
|
-
thesis: "thesis";
|
|
269
|
-
}>>>, unknown>;
|
|
270
|
-
subjects: import("zod").ZodPreprocess<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
|
|
271
|
-
Accelerators: "Accelerators";
|
|
272
|
-
Astrophysics: "Astrophysics";
|
|
273
|
-
Computing: "Computing";
|
|
274
|
-
"Condensed Matter": "Condensed Matter";
|
|
275
|
-
"Data Analysis and Statistics": "Data Analysis and Statistics";
|
|
276
|
-
"Experiment-HEP": "Experiment-HEP";
|
|
277
|
-
"Experiment-Nucl": "Experiment-Nucl";
|
|
278
|
-
"General Physics": "General Physics";
|
|
279
|
-
"Gravitation and Cosmology": "Gravitation and Cosmology";
|
|
280
|
-
Instrumentation: "Instrumentation";
|
|
281
|
-
Lattice: "Lattice";
|
|
282
|
-
"Math and Math Physics": "Math and Math Physics";
|
|
283
|
-
Other: "Other";
|
|
284
|
-
"Phenomenology-HEP": "Phenomenology-HEP";
|
|
285
|
-
"Quantum Physics": "Quantum Physics";
|
|
286
|
-
"Theory-HEP": "Theory-HEP";
|
|
287
|
-
"Theory-Nucl": "Theory-Nucl";
|
|
288
|
-
Unknown: "Unknown";
|
|
289
|
-
}>>>, unknown>;
|
|
290
|
-
year_from: import("zod").ZodPreprocess<import("zod").ZodOptional<import("zod").ZodNumber>, unknown>;
|
|
291
|
-
year_to: import("zod").ZodPreprocess<import("zod").ZodOptional<import("zod").ZodNumber>, unknown>;
|
|
292
|
-
sort: import("zod").ZodPreprocess<import("zod").ZodDefault<import("zod").ZodEnum<{
|
|
293
|
-
mostcited: "mostcited";
|
|
294
|
-
mostrecent: "mostrecent";
|
|
295
|
-
relevance: "relevance";
|
|
296
|
-
}>>, unknown>;
|
|
297
|
-
page: import("zod").ZodPreprocess<import("zod").ZodDefault<import("zod").ZodNumber>, unknown>;
|
|
298
|
-
size: import("zod").ZodPreprocess<import("zod").ZodDefault<import("zod").ZodNumber>, unknown>;
|
|
299
|
-
}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
|
|
300
|
-
format: import("zod").ZodEnum<{
|
|
301
|
-
bibtex: "bibtex";
|
|
302
|
-
"latex-eu": "latex-eu";
|
|
303
|
-
"latex-us": "latex-us";
|
|
304
|
-
}>;
|
|
305
|
-
page: import("zod").ZodNumber;
|
|
306
|
-
entries: import("zod").ZodArray<import("zod").ZodObject<{
|
|
307
|
-
texkey: import("zod").ZodString;
|
|
308
|
-
text: import("zod").ZodString;
|
|
309
|
-
}, import("zod/v4/core").$strip>>;
|
|
310
|
-
}, import("zod/v4/core").$strip>, readonly [{
|
|
311
|
-
readonly reason: "invalid_year_range";
|
|
312
|
-
readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
|
|
313
|
-
readonly when: "year_from is later than year_to.";
|
|
314
|
-
readonly recovery: "Swap year_from and year_to so the range runs forward, or drop one bound for an open range, then retry this call.";
|
|
315
|
-
readonly severity: "notice";
|
|
316
|
-
}, {
|
|
317
|
-
readonly reason: "beyond_result_window";
|
|
318
|
-
readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
|
|
319
|
-
readonly when: "page × effective size (after clamping) exceeds the 10,000 results INSPIRE serves for one query.";
|
|
320
|
-
readonly recovery: "Narrow the query with tighter terms, such as a date range (\"and date > 2015\") or a collaboration, until it matches under 10,000 papers, then page again with cern_inspire_export_citations.";
|
|
321
|
-
readonly severity: "notice";
|
|
322
|
-
}, {
|
|
323
|
-
readonly reason: "invalid_query";
|
|
324
|
-
readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
|
|
325
|
-
readonly when: "A recognized field clause has no value, or INSPIRE answered 400 to a parameter value it refuses.";
|
|
326
|
-
readonly recovery: "Give every field a value (for example \"a Witten\"), check cern_inspire_list_reference topic search_syntax, then retry cern_inspire_export_citations.";
|
|
327
|
-
readonly severity: "notice";
|
|
328
|
-
readonly thrownBy: "service";
|
|
329
|
-
}, {
|
|
330
|
-
readonly reason: "inspire_rate_limited";
|
|
331
|
-
readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.RateLimited;
|
|
332
|
-
readonly when: "INSPIRE returned 429 after the pacer and retries.";
|
|
333
|
-
readonly recovery: "Wait the retry-after seconds this error states (at least 5), then retry this call; INSPIRE allows 15 requests per 5 seconds from one address.";
|
|
334
|
-
readonly retryable: true;
|
|
335
|
-
readonly thrownBy: "service";
|
|
336
|
-
}, {
|
|
337
|
-
readonly reason: "pacer_shed";
|
|
338
|
-
readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.RateLimited;
|
|
339
|
-
readonly when: "The server's outbound INSPIRE queue could not start the request within the call's remaining budget.";
|
|
340
|
-
readonly recovery: "This server's INSPIRE request queue is saturated; wait the seconds in this error's retryAfter field (about 5 when it is not shown), then retry this call with fewer cern_inspire calls running in parallel.";
|
|
341
|
-
readonly retryable: true;
|
|
342
|
-
readonly thrownBy: "service";
|
|
343
|
-
}, {
|
|
344
|
-
readonly reason: "upstream_unreadable";
|
|
345
|
-
readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ServiceUnavailable;
|
|
346
|
-
readonly when: "The INSPIRE body exceeded the byte ceiling, the citation page was JSON or HTML instead of citation text, or selection verification returned unreadable JSON.";
|
|
347
|
-
readonly recovery: "Retry this call in a few seconds; if it fails again, INSPIRE is likely serving an error page, so wait a minute before retrying cern_inspire_export_citations with the same page and size.";
|
|
348
|
-
readonly thrownBy: "service";
|
|
349
|
-
}], {
|
|
350
|
-
readonly appliedFilters: import("zod").ZodString;
|
|
351
|
-
readonly truncated: import("zod").ZodBoolean;
|
|
352
|
-
readonly shown: import("zod").ZodNumber;
|
|
353
|
-
readonly cap: import("zod").ZodNumber;
|
|
354
|
-
readonly nextPage: import("zod").ZodOptional<import("zod").ZodNumber>;
|
|
355
|
-
readonly notice: import("zod").ZodOptional<import("zod").ZodString>;
|
|
356
456
|
}> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
|
|
357
457
|
query: import("zod").ZodPreprocess<import("zod").ZodString, unknown>;
|
|
458
|
+
page: import("zod").ZodPreprocess<import("zod").ZodDefault<import("zod").ZodNumber>, unknown>;
|
|
358
459
|
limit: import("zod").ZodPreprocess<import("zod").ZodDefault<import("zod").ZodNumber>, unknown>;
|
|
359
460
|
}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
|
|
360
461
|
authors: import("zod").ZodArray<import("zod").ZodObject<{
|
|
@@ -400,7 +501,16 @@ export declare const allToolDefinitions: (import("@cyanheads/mcp-ts-core").ToolD
|
|
|
400
501
|
}, import("zod/v4/core").$strip>>;
|
|
401
502
|
literatureQuery: import("zod").ZodString;
|
|
402
503
|
}, import("zod/v4/core").$strip>>;
|
|
504
|
+
page: import("zod").ZodNumber;
|
|
505
|
+
limit: import("zod").ZodNumber;
|
|
506
|
+
hasMore: import("zod").ZodBoolean;
|
|
403
507
|
}, import("zod/v4/core").$strip>, readonly [{
|
|
508
|
+
readonly reason: "beyond_result_window";
|
|
509
|
+
readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
|
|
510
|
+
readonly when: "page × effective limit (after clamping) exceeds the 10,000 results INSPIRE serves for one query.";
|
|
511
|
+
readonly recovery: "Pin the person with a BAI, ORCID, or INSPIRE ID (cern_inspire_get_paper lists them for a paper's authors), then retry cern_inspire_search_authors; extra name parts widen a name search, since INSPIRE reads them as initials.";
|
|
512
|
+
readonly severity: "notice";
|
|
513
|
+
}, {
|
|
404
514
|
readonly reason: "invalid_query";
|
|
405
515
|
readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
|
|
406
516
|
readonly when: "INSPIRE answered 400 to a parameter value it refuses.";
|
|
@@ -425,13 +535,14 @@ export declare const allToolDefinitions: (import("@cyanheads/mcp-ts-core").ToolD
|
|
|
425
535
|
readonly reason: "upstream_unreadable";
|
|
426
536
|
readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ServiceUnavailable;
|
|
427
537
|
readonly when: "The INSPIRE body exceeded the byte ceiling, was HTML where JSON was expected, or was invalid JSON.";
|
|
428
|
-
readonly recovery: "Retry this call in a few seconds; if it fails again,
|
|
538
|
+
readonly recovery: "Retry this call in a few seconds; if it fails again, INSPIRE is likely serving an error page, so wait a minute before retrying cern_inspire_search_authors with the same page and limit.";
|
|
429
539
|
readonly thrownBy: "service";
|
|
430
540
|
}], {
|
|
431
541
|
readonly totalCount: import("zod").ZodNumber;
|
|
432
542
|
readonly truncated: import("zod").ZodBoolean;
|
|
433
543
|
readonly shown: import("zod").ZodNumber;
|
|
434
544
|
readonly cap: import("zod").ZodNumber;
|
|
545
|
+
readonly nextPage: import("zod").ZodOptional<import("zod").ZodNumber>;
|
|
435
546
|
readonly matchedAs: import("zod").ZodString;
|
|
436
547
|
readonly notice: import("zod").ZodOptional<import("zod").ZodString>;
|
|
437
548
|
}> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
|
|
@@ -588,45 +699,41 @@ export declare const allToolDefinitions: (import("@cyanheads/mcp-ts-core").ToolD
|
|
|
588
699
|
readonly notice: import("zod").ZodOptional<import("zod").ZodString>;
|
|
589
700
|
}> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
|
|
590
701
|
query: import("zod").ZodString;
|
|
702
|
+
page: import("zod").ZodPreprocess<import("zod").ZodDefault<import("zod").ZodNumber>, unknown>;
|
|
591
703
|
limit: import("zod").ZodPreprocess<import("zod").ZodDefault<import("zod").ZodNumber>, unknown>;
|
|
592
704
|
}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
|
|
593
|
-
|
|
705
|
+
institutions: import("zod").ZodArray<import("zod").ZodObject<{
|
|
594
706
|
recid: import("zod").ZodString;
|
|
595
|
-
|
|
596
|
-
|
|
597
|
-
|
|
598
|
-
|
|
599
|
-
accelerator: import("zod").ZodOptional<import("zod").ZodString>;
|
|
600
|
-
institutions: import("zod").ZodArray<import("zod").ZodObject<{
|
|
601
|
-
name: import("zod").ZodString;
|
|
602
|
-
recid: import("zod").ZodOptional<import("zod").ZodString>;
|
|
707
|
+
legacyIcn: import("zod").ZodOptional<import("zod").ZodString>;
|
|
708
|
+
hierarchy: import("zod").ZodArray<import("zod").ZodObject<{
|
|
709
|
+
name: import("zod").ZodOptional<import("zod").ZodString>;
|
|
710
|
+
acronym: import("zod").ZodOptional<import("zod").ZodString>;
|
|
603
711
|
}, import("zod/v4/core").$strip>>;
|
|
604
|
-
|
|
605
|
-
|
|
606
|
-
|
|
607
|
-
}, import("zod/v4/core").$strip>>;
|
|
608
|
-
classification: import("zod").ZodArray<import("zod").ZodString>;
|
|
609
|
-
projectTypes: import("zod").ZodArray<import("zod").ZodString>;
|
|
610
|
-
dateProposed: import("zod").ZodOptional<import("zod").ZodString>;
|
|
611
|
-
dateApproved: import("zod").ZodOptional<import("zod").ZodString>;
|
|
612
|
-
dateStarted: import("zod").ZodOptional<import("zod").ZodString>;
|
|
613
|
-
dateCompleted: import("zod").ZodOptional<import("zod").ZodString>;
|
|
614
|
-
ongoing: import("zod").ZodOptional<import("zod").ZodBoolean>;
|
|
712
|
+
institutionTypes: import("zod").ZodArray<import("zod").ZodString>;
|
|
713
|
+
cities: import("zod").ZodArray<import("zod").ZodString>;
|
|
714
|
+
countryCodes: import("zod").ZodArray<import("zod").ZodString>;
|
|
615
715
|
numberOfPapers: import("zod").ZodOptional<import("zod").ZodNumber>;
|
|
616
|
-
|
|
617
|
-
|
|
618
|
-
|
|
619
|
-
description: import("zod").ZodOptional<import("zod").ZodString>;
|
|
716
|
+
relatedRecords: import("zod").ZodArray<import("zod").ZodObject<{
|
|
717
|
+
recid: import("zod").ZodString;
|
|
718
|
+
relation: import("zod").ZodOptional<import("zod").ZodString>;
|
|
620
719
|
}, import("zod/v4/core").$strip>>;
|
|
621
|
-
|
|
622
|
-
|
|
623
|
-
literatureQuery: import("zod").ZodOptional<import("zod").ZodString>;
|
|
720
|
+
inactive: import("zod").ZodOptional<import("zod").ZodBoolean>;
|
|
721
|
+
literatureQuery: import("zod").ZodString;
|
|
624
722
|
}, import("zod/v4/core").$strip>>;
|
|
723
|
+
page: import("zod").ZodNumber;
|
|
724
|
+
limit: import("zod").ZodNumber;
|
|
725
|
+
hasMore: import("zod").ZodBoolean;
|
|
625
726
|
}, import("zod/v4/core").$strip>, readonly [{
|
|
727
|
+
readonly reason: "beyond_result_window";
|
|
728
|
+
readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
|
|
729
|
+
readonly when: "page × effective limit (after clamping) exceeds the 10,000 results INSPIRE serves for one query.";
|
|
730
|
+
readonly recovery: "Narrow the query with more name words, the city, or the exact legacy_ICN:\"NAME\" form until it matches under 10,000 records, then page again with cern_inspire_search_institutions.";
|
|
731
|
+
readonly severity: "notice";
|
|
732
|
+
}, {
|
|
626
733
|
readonly reason: "invalid_query";
|
|
627
734
|
readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
|
|
628
735
|
readonly when: "INSPIRE answered 400 to a parameter value it refuses.";
|
|
629
|
-
readonly recovery: "Retry
|
|
736
|
+
readonly recovery: "Retry cern_inspire_search_institutions with plain institution name words, or one legacy_ICN:\"NAME\" clause with the name in double quotes.";
|
|
630
737
|
readonly severity: "notice";
|
|
631
738
|
readonly thrownBy: "service";
|
|
632
739
|
}, {
|
|
@@ -647,13 +754,14 @@ export declare const allToolDefinitions: (import("@cyanheads/mcp-ts-core").ToolD
|
|
|
647
754
|
readonly reason: "upstream_unreadable";
|
|
648
755
|
readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ServiceUnavailable;
|
|
649
756
|
readonly when: "The INSPIRE body exceeded the byte ceiling, was HTML where JSON was expected, or was invalid JSON.";
|
|
650
|
-
readonly recovery: "Retry this call in a few seconds; if it fails again,
|
|
757
|
+
readonly recovery: "Retry this call in a few seconds; if it fails again, INSPIRE is likely serving an error page, so wait a minute before retrying cern_inspire_search_institutions with the same page and limit.";
|
|
651
758
|
readonly thrownBy: "service";
|
|
652
759
|
}], {
|
|
653
760
|
readonly totalCount: import("zod").ZodNumber;
|
|
654
761
|
readonly truncated: import("zod").ZodBoolean;
|
|
655
762
|
readonly shown: import("zod").ZodNumber;
|
|
656
763
|
readonly cap: import("zod").ZodNumber;
|
|
764
|
+
readonly nextPage: import("zod").ZodOptional<import("zod").ZodNumber>;
|
|
657
765
|
readonly notice: import("zod").ZodOptional<import("zod").ZodString>;
|
|
658
766
|
}> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
|
|
659
767
|
query: import("zod").ZodString;
|
|
@@ -693,8 +801,8 @@ export declare const allToolDefinitions: (import("@cyanheads/mcp-ts-core").ToolD
|
|
|
693
801
|
}, {
|
|
694
802
|
readonly reason: "invalid_query";
|
|
695
803
|
readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
|
|
696
|
-
readonly when: "INSPIRE answered 400 to a parameter value it refuses.";
|
|
697
|
-
readonly recovery: "
|
|
804
|
+
readonly when: "A recognized field clause has no value, or INSPIRE answered 400 to a parameter value it refuses.";
|
|
805
|
+
readonly recovery: "Give every field a value (for example \"t higgs\"), check cern_inspire_list_reference topic search_syntax, then retry cern_inspire_search_hepdata.";
|
|
698
806
|
readonly severity: "notice";
|
|
699
807
|
readonly thrownBy: "service";
|
|
700
808
|
}, {
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;
|
|
1
|
+
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAYH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0DAU9B,CAAC"}
|
|
@@ -9,6 +9,7 @@ import { listReferenceTool } from './list-reference.tool.js';
|
|
|
9
9
|
import { searchAuthorsTool } from './search-authors.tool.js';
|
|
10
10
|
import { searchExperimentsTool } from './search-experiments.tool.js';
|
|
11
11
|
import { searchHepdataTool } from './search-hepdata.tool.js';
|
|
12
|
+
import { searchInstitutionsTool } from './search-institutions.tool.js';
|
|
12
13
|
import { searchLiteratureTool } from './search-literature.tool.js';
|
|
13
14
|
export const allToolDefinitions = [
|
|
14
15
|
searchLiteratureTool,
|
|
@@ -17,6 +18,7 @@ export const allToolDefinitions = [
|
|
|
17
18
|
searchAuthorsTool,
|
|
18
19
|
getCitationSummaryTool,
|
|
19
20
|
searchExperimentsTool,
|
|
21
|
+
searchInstitutionsTool,
|
|
20
22
|
searchHepdataTool,
|
|
21
23
|
listReferenceTool,
|
|
22
24
|
];
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,oBAAoB;IACpB,YAAY;IACZ,mBAAmB;IACnB,iBAAiB;IACjB,sBAAsB;IACtB,qBAAqB;IACrB,iBAAiB;IACjB,iBAAiB;CAClB,CAAC"}
|
|
1
|
+
{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,oBAAoB;IACpB,YAAY;IACZ,mBAAmB;IACnB,iBAAiB;IACjB,sBAAsB;IACtB,qBAAqB;IACrB,sBAAsB;IACtB,iBAAiB;IACjB,iBAAiB;CAClB,CAAC"}
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"list-reference.tool.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/list-reference.tool.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAQ,CAAC,EAAE,MAAM,wBAAwB,CAAC;
|
|
1
|
+
{"version":3,"file":"list-reference.tool.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/list-reference.tool.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAQ,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAwWjD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;wCA6C5B,CAAC"}
|
|
@@ -90,12 +90,12 @@ const REFERENCE = {
|
|
|
90
90
|
},
|
|
91
91
|
{
|
|
92
92
|
term: 'refersto:recid:N',
|
|
93
|
-
meaning: 'Papers that cite record N (its citations).',
|
|
93
|
+
meaning: 'Papers that cite record N (its citations). Takes a recid only: an arXiv value selects a different set. cern_inspire_get_paper returns this query for a paper as citingQuery.',
|
|
94
94
|
example: 'refersto:recid:1124337',
|
|
95
95
|
},
|
|
96
96
|
{
|
|
97
97
|
term: 'citedby:recid:N',
|
|
98
|
-
meaning: 'Papers that record N cites (its references).',
|
|
98
|
+
meaning: 'Papers that record N cites (its references). Takes a recid only: an arXiv value selects a different set. cern_inspire_get_paper returns this query for a paper as referencesQuery.',
|
|
99
99
|
example: 'citedby:recid:1124337',
|
|
100
100
|
},
|
|
101
101
|
{
|
|
@@ -103,10 +103,15 @@ const REFERENCE = {
|
|
|
103
103
|
meaning: 'Journal publication; the volume and page are optional.',
|
|
104
104
|
example: 'j Phys.Lett.B,716,1',
|
|
105
105
|
},
|
|
106
|
+
{
|
|
107
|
+
term: 'publication_info.cnum:CNUM',
|
|
108
|
+
meaning: "A conference's contributions, by the conference number (CNUM) cern_inspire_get_paper reports in publications[].cnum. Spell out the field path: cnum CNUM and cnum:CNUM match nothing.",
|
|
109
|
+
example: 'publication_info.cnum:C22-07-06.1',
|
|
110
|
+
},
|
|
106
111
|
{ term: 'eprint ID', meaning: 'arXiv eprint number.', example: 'eprint 1207.7214' },
|
|
107
112
|
{
|
|
108
113
|
term: 'arxiv:ID',
|
|
109
|
-
meaning: 'arXiv ID, new or old style
|
|
114
|
+
meaning: 'arXiv ID, new or old style. INSPIRE indexes it without a version, so the query of cern_inspire_search_literature, cern_inspire_export_citations, and cern_inspire_get_citation_summary removes a vN suffix before sending and names the rewrite in a notice.',
|
|
110
115
|
example: 'arxiv:hep-th/9711200',
|
|
111
116
|
},
|
|
112
117
|
{
|
|
@@ -126,12 +131,12 @@ const REFERENCE = {
|
|
|
126
131
|
},
|
|
127
132
|
{
|
|
128
133
|
term: 'aff NAME',
|
|
129
|
-
meaning: 'Papers with an author whose affiliation INSPIRE records under that institution name: its curated short name, such as CERN, not the affiliation text printed on the paper; case-insensitive. affid:N is more complete.',
|
|
134
|
+
meaning: 'Papers with an author whose affiliation INSPIRE records under that institution name: its curated short name, such as CERN, not the affiliation text printed on the paper; case-insensitive. cern_inspire_search_institutions returns that name as legacyIcn. affid:N is more complete.',
|
|
130
135
|
example: 'aff CERN',
|
|
131
136
|
},
|
|
132
137
|
{
|
|
133
138
|
term: 'affid:N',
|
|
134
|
-
meaning: "Papers linked to institution record N through an author's or supervisor's affiliation, a thesis institution, or a record-level affiliation. N is the institution recid cern_inspire_search_authors (institutionRecid) and cern_inspire_search_experiments (institutions[].recid) return
|
|
139
|
+
meaning: "Papers linked to institution record N through an author's or supervisor's affiliation, a thesis institution, or a record-level affiliation. N is the institution recid cern_inspire_search_institutions finds by name (recid, with this query as literatureQuery), and cern_inspire_search_authors (institutionRecid) and cern_inspire_search_experiments (institutions[].recid) return. It matches record N alone, not its departments or parent institution: join several with or. As the query of cern_inspire_get_citation_summary it gives the institution's citation summary.",
|
|
135
140
|
example: 'affid:902725',
|
|
136
141
|
},
|
|
137
142
|
{
|
|
@@ -145,7 +150,7 @@ const REFERENCE = {
|
|
|
145
150
|
},
|
|
146
151
|
{
|
|
147
152
|
term: '10,000-result window',
|
|
148
|
-
meaning: 'INSPIRE serves at most the first 10,000 results of a query
|
|
153
|
+
meaning: 'INSPIRE serves at most the first 10,000 results of a query: page × size, or page × limit in cern_inspire_search_authors, cern_inspire_search_experiments, and cern_inspire_search_institutions, may not exceed 10,000. Narrow the query to reach further.',
|
|
149
154
|
},
|
|
150
155
|
{
|
|
151
156
|
term: 'document_types / subjects filters',
|
|
@@ -159,12 +164,12 @@ const REFERENCE = {
|
|
|
159
164
|
identifiers: [
|
|
160
165
|
{
|
|
161
166
|
term: 'recid',
|
|
162
|
-
meaning: 'INSPIRE record ID, an integer. Literature, authors, experiments, and
|
|
167
|
+
meaning: 'INSPIRE record ID, an integer. Literature, authors, experiments, institutions, and conferences each number their own records.',
|
|
163
168
|
example: '1124337',
|
|
164
169
|
},
|
|
165
170
|
{
|
|
166
171
|
term: 'arXiv ID',
|
|
167
|
-
meaning: "New style NNNN.NNNNN or old style archive/NNNNNNN. INSPIRE stores it without a version suffix: the paper input of cern_inspire_get_paper strips 'arXiv:', vN, and arxiv.org URLs,
|
|
172
|
+
meaning: "New style NNNN.NNNNN or old style archive/NNNNNNN. INSPIRE stores it without a version suffix: the paper input of cern_inspire_get_paper strips 'arXiv:', vN (either case), and arxiv.org URLs, and cern_inspire_search_literature, cern_inspire_export_citations, and cern_inspire_get_citation_summary send an arXiv clause's ID without its vN, with a notice. refersto: and citedby: values are sent as written.",
|
|
168
173
|
example: '1207.7214',
|
|
169
174
|
},
|
|
170
175
|
{
|
|
@@ -199,9 +204,14 @@ const REFERENCE = {
|
|
|
199
204
|
},
|
|
200
205
|
{
|
|
201
206
|
term: 'institution recid',
|
|
202
|
-
meaning: "An institution's recid,
|
|
207
|
+
meaning: "An institution's recid: cern_inspire_search_institutions finds it from a name, and institutionRecid (cern_inspire_search_authors), institutions[].recid (cern_inspire_search_experiments), and thesis.institutions[].recid (cern_inspire_get_paper) return it; select its papers with affid:N in cern_inspire_search_literature or cern_inspire_get_citation_summary.",
|
|
203
208
|
example: '902725',
|
|
204
209
|
},
|
|
210
|
+
{
|
|
211
|
+
term: 'institution legacy ICN',
|
|
212
|
+
meaning: 'The name INSPIRE records for an institution on papers: what authors[].affiliations in cern_inspire_get_paper and legacyIcn in cern_inspire_search_institutions carry, and what aff NAME matches. legacy_ICN:"NAME" as the query of cern_inspire_search_institutions finds its record, exact and case-sensitive, one name per call.',
|
|
213
|
+
example: 'Tokyo U.',
|
|
214
|
+
},
|
|
205
215
|
{
|
|
206
216
|
term: 'texkey',
|
|
207
217
|
meaning: "INSPIRE's citation key, used by the BibTeX and LaTeX entries of cern_inspire_export_citations.",
|