scholar-mcp 1.0.0

package/dist/research/literature-service.js

@@ -0,0 +1,387 @@
+import { normalizeDoi, normalizeWhitespace, parseYear, tokenizeForRanking } from './utils.js';
+import { ResearchHttpClient } from './http-client.js';
+import { OpenAlexClient } from './providers/openalex-client.js';
+import { CrossrefClient } from './providers/crossref-client.js';
+import { SemanticScholarClient } from './providers/semantic-scholar-client.js';
+const providerWeight = {
+    openalex: 1,
+    crossref: 0.9,
+    semantic_scholar: 1.1,
+    scholar_scrape: 0.7
+};
+const DEFAULT_SOURCES = ['openalex', 'crossref', 'semantic_scholar'];
+const scoreFromCitations = (citations) => {
+    if (citations <= 0) {
+        return 0;
+    }
+    return Math.min(1, Math.log10(citations + 1) / 4);
+};
+const normalizeTitleKey = (title) => normalizeWhitespace(title)
+    .toLowerCase()
+    .replace(/[^a-z0-9\s]/g, '');
+const tokenSetFromTitle = (title) => new Set(tokenizeForRanking(title));
+const setJaccard = (a, b) => {
+    if (a.size === 0 || b.size === 0) {
+        return 0;
+    }
+    let overlap = 0;
+    for (const token of a) {
+        if (b.has(token)) {
+            overlap += 1;
+        }
+    }
+    return overlap / (a.size + b.size - overlap);
+};
+const mergeFields = (current, incoming) => {
+    const set = new Set(current);
+    for (const value of incoming) {
+        if (value) {
+            set.add(value);
+        }
+    }
+    return [...set];
+};
+const isWithinYearRange = (year, range) => {
+    if (!range || !year) {
+        return true;
+    }
+    return year >= range[0] && year <= range[1];
+};
+const matchesFieldOfStudy = (work, requestedFields) => {
+    if (!requestedFields || requestedFields.length === 0) {
+        return true;
+    }
+    const normalized = new Set(work.fieldsOfStudy.map((field) => field.trim().toLowerCase()));
+    return requestedFields.some((field) => normalized.has(field.trim().toLowerCase()));
+};
+const yearsCompatible = (a, b) => !a || !b || Math.abs(a - b) <= 2;
+const normalizeAuthorName = (name) => normalizeWhitespace(name)
+    .toLowerCase()
+    .replace(/[^a-z0-9\s]/g, '');
+const sharesAuthorSignal = (left, right) => {
+    if (left.length === 0 || right.length === 0) {
+        return true;
+    }
+    const leftIds = new Set(left.map((author) => author.authorId).filter((id) => Boolean(id)));
+    if (leftIds.size > 0 && right.some((author) => author.authorId && leftIds.has(author.authorId))) {
+        return true;
+    }
+    const leftNames = new Set(left.map((author) => normalizeAuthorName(author.name)).filter((name) => name.length > 0));
+    return right.some((author) => leftNames.has(normalizeAuthorName(author.name)));
+};
+const cloneResult = (value) => {
+    try {
+        return structuredClone(value);
+    }
+    catch {
+        return JSON.parse(JSON.stringify(value));
+    }
+};
+export class LiteratureService {
+    config;
+    logger;
+    scholarService;
+    httpClient;
+    openAlexClient;
+    crossrefClient;
+    semanticScholarClient;
+    searchCache = new Map();
+    constructor(config, logger, scholarService) {
+        this.config = config;
+        this.logger = logger;
+        this.scholarService = scholarService;
+        this.httpClient = new ResearchHttpClient(config);
+        this.openAlexClient = new OpenAlexClient(config, this.httpClient);
+        this.crossrefClient = new CrossrefClient(config, this.httpClient);
+        this.semanticScholarClient = new SemanticScholarClient(config, this.httpClient);
+    }
+    async searchGraph(input) {
+        const requestedSources = new Set(input.sources ?? DEFAULT_SOURCES);
+        const cacheKey = this.createCacheKey(input, requestedSources);
+        const cached = this.getCache(cacheKey);
+        if (cached) {
+            this.logger.debug('Returning literature graph result from cache', {
+                query: input.query,
+                sources: [...requestedSources],
+                limit: input.limit
+            });
+            return cached;
+        }
+        const providerErrors = [];
+        const providerLimit = Math.max(input.limit, Math.ceil(input.limit * this.config.researchGraphProviderResultMultiplier));
+        const providerPromises = [];
+        if (requestedSources.has('openalex')) {
+            providerPromises.push(this.openAlexClient.searchWorks(input.query, providerLimit).catch((error) => {
+                providerErrors.push({ provider: 'openalex', message: error instanceof Error ? error.message : String(error) });
+                return [];
+            }));
+        }
+        if (requestedSources.has('crossref')) {
+            providerPromises.push(this.crossrefClient.searchWorks(input.query, providerLimit).catch((error) => {
+                providerErrors.push({ provider: 'crossref', message: error instanceof Error ? error.message : String(error) });
+                return [];
+            }));
+        }
+        if (requestedSources.has('semantic_scholar')) {
+            providerPromises.push(this.semanticScholarClient.searchWorks(input.query, providerLimit).catch((error) => {
+                providerErrors.push({
+                    provider: 'semantic_scholar',
+                    message: error instanceof Error ? error.message : String(error)
+                });
+                return [];
+            }));
+        }
+        if (requestedSources.has('scholar_scrape')) {
+            providerPromises.push(this.searchWithScholarScrape(input.query, providerLimit).catch((error) => {
+                providerErrors.push({ provider: 'scholar_scrape', message: error instanceof Error ? error.message : String(error) });
+                return [];
+            }));
+        }
+        const providerResults = (await Promise.all(providerPromises)).flat();
+        const filtered = providerResults.filter((work) => isWithinYearRange(work.year, input.yearRange) && matchesFieldOfStudy(work, input.fieldsOfStudy));
+        const merged = new Map();
+        const doiToKey = new Map();
+        const titleToKeys = new Map();
+        const indexTitle = (titleKey, key) => {
+            const existing = titleToKeys.get(titleKey) ?? new Set();
+            existing.add(key);
+            titleToKeys.set(titleKey, existing);
+        };
+        const resolveTargetKey = (work) => {
+            const normalizedDoi = normalizeDoi(work.doi);
+            if (normalizedDoi && doiToKey.has(normalizedDoi)) {
+                return doiToKey.get(normalizedDoi) ?? null;
+            }
+            const titleKey = normalizeTitleKey(work.title);
+            const exactCandidateKeys = [...(titleToKeys.get(titleKey) ?? [])];
+            for (const key of exactCandidateKeys) {
+                const candidate = merged.get(key);
+                if (!candidate) {
+                    continue;
+                }
+                if (yearsCompatible(candidate.year, work.year) && sharesAuthorSignal(candidate.authors, work.authors)) {
+                    return key;
+                }
+            }
+            const incomingTokens = tokenSetFromTitle(work.title);
+            let bestKey = null;
+            let bestSimilarity = 0;
+            for (const [key, candidate] of merged.entries()) {
+                if (!yearsCompatible(candidate.year, work.year)) {
+                    continue;
+                }
+                if (!sharesAuthorSignal(candidate.authors, work.authors)) {
+                    continue;
+                }
+                const similarity = setJaccard(tokenSetFromTitle(candidate.title), incomingTokens);
+                if (similarity > bestSimilarity) {
+                    bestSimilarity = similarity;
+                    bestKey = key;
+                }
+            }
+            if (bestKey && bestSimilarity >= this.config.researchGraphFuzzyTitleThreshold) {
+                return bestKey;
+            }
+            return null;
+        };
+        for (const work of filtered) {
+            const targetKey = resolveTargetKey(work);
+            const normalizedDoi = normalizeDoi(work.doi);
+            const titleKey = normalizeTitleKey(work.title);
+            const confidence = providerWeight[work.provider] ?? 0.8;
+            const provenance = {
+                provider: work.provider,
+                sourceUrl: work.sourceUrl,
+                fetchedAt: new Date().toISOString(),
+                confidence
+            };
+            const relevanceScore = 0.6 * work.score + 0.3 * scoreFromCitations(work.citationCount) + 0.1 * confidence;
+            if (!targetKey) {
+                const generatedKey = normalizedDoi ?? `title:${titleKey}:year:${work.year ?? 'na'}`;
+                merged.set(generatedKey, {
+                    title: work.title,
+                    abstract: work.abstract,
+                    year: work.year,
+                    venue: work.venue,
+                    doi: normalizedDoi,
+                    url: work.url,
+                    paperId: work.providerId,
+                    citationCount: work.citationCount,
+                    influentialCitationCount: work.influentialCitationCount,
+                    referenceCount: work.referenceCount,
+                    authors: work.authors,
+                    openAccess: {
+                        isOpenAccess: work.openAccess.isOpenAccess,
+                        pdfUrl: work.openAccess.pdfUrl,
+                        license: work.openAccess.license
+                    },
+                    externalIds: work.externalIds,
+                    fieldsOfStudy: work.fieldsOfStudy,
+                    score: relevanceScore,
+                    provenance: [provenance]
+                });
+                if (normalizedDoi) {
+                    doiToKey.set(normalizedDoi, generatedKey);
+                }
+                indexTitle(titleKey, generatedKey);
+                continue;
+            }
+            const existing = merged.get(targetKey);
+            if (!existing) {
+                continue;
+            }
+            existing.abstract = existing.abstract ?? work.abstract;
+            existing.year = existing.year ?? work.year;
+            existing.venue = existing.venue ?? work.venue;
+            existing.url = existing.url ?? work.url;
+            existing.doi = existing.doi ?? normalizedDoi;
+            existing.citationCount = Math.max(existing.citationCount, work.citationCount);
+            existing.influentialCitationCount = Math.max(existing.influentialCitationCount, work.influentialCitationCount);
+            existing.referenceCount = Math.max(existing.referenceCount, work.referenceCount);
+            existing.authors = existing.authors.length > 0 ? existing.authors : work.authors;
+            existing.fieldsOfStudy = mergeFields(existing.fieldsOfStudy, work.fieldsOfStudy);
+            existing.externalIds = {
+                ...existing.externalIds,
+                ...work.externalIds
+            };
+            existing.openAccess = {
+                isOpenAccess: existing.openAccess.isOpenAccess || work.openAccess.isOpenAccess,
+                pdfUrl: existing.openAccess.pdfUrl ?? work.openAccess.pdfUrl,
+                license: existing.openAccess.license ?? work.openAccess.license
+            };
+            existing.provenance.push(provenance);
+            existing.score = Math.max(existing.score, relevanceScore);
+            const latestDoi = existing.doi ?? normalizedDoi;
+            if (latestDoi) {
+                doiToKey.set(latestDoi, targetKey);
+            }
+            indexTitle(titleKey, targetKey);
+        }
+        const currentYear = new Date().getFullYear();
+        const ranked = [...merged.values()]
+            .map((work) => {
+            const citationScore = scoreFromCitations(work.citationCount);
+            const recencyScore = work.year ? 1 / Math.max(1, currentYear - work.year + 1) : 0.15;
+            const diversityScore = Math.min(1, new Set(work.provenance.map((record) => record.provider)).size / Math.max(1, requestedSources.size));
+            const blended = 0.5 * work.score + 0.25 * citationScore + 0.15 * diversityScore + 0.1 * Math.min(1, recencyScore * 2);
+            return {
+                ...work,
+                score: blended
+            };
+        })
+            .sort((a, b) => b.score - a.score || (b.citationCount ?? 0) - (a.citationCount ?? 0))
+            .slice(0, input.limit);
+        const result = {
+            query: input.query,
+            totalResults: ranked.length,
+            results: ranked,
+            providerErrors
+        };
+        this.setCache(cacheKey, result);
+        this.logger.debug('Literature graph search complete', {
+            query: input.query,
+            providers: [...requestedSources],
+            providerLimit,
+            mergedCount: ranked.length,
+            providerErrors
+        });
+        return cloneResult(result);
+    }
+    async resolveByDoi(doi) {
+        const normalized = normalizeDoi(doi);
+        if (!normalized) {
+            return null;
+        }
+        const result = await this.searchGraph({
+            query: normalized,
+            limit: 10,
+            sources: ['openalex', 'crossref', 'semantic_scholar']
+        });
+        return (result.results.find((item) => normalizeDoi(item.doi) === normalized) ??
+            result.results.find((item) => normalizeDoi(item.externalIds.doi) === normalized) ??
+            result.results[0] ??
+            null);
+    }
+    createCacheKey(input, sources) {
+        const normalizedFields = (input.fieldsOfStudy ?? []).map((field) => field.trim().toLowerCase()).sort();
+        const normalizedSources = [...sources].sort();
+        const normalizedYearRange = input.yearRange ? `${input.yearRange[0]}:${input.yearRange[1]}` : 'none';
+        return JSON.stringify({
+            query: normalizeWhitespace(input.query).toLowerCase(),
+            limit: input.limit,
+            yearRange: normalizedYearRange,
+            fields: normalizedFields,
+            sources: normalizedSources
+        });
+    }
+    getCache(cacheKey) {
+        if (this.config.researchGraphCacheTtlMs <= 0) {
+            return null;
+        }
+        const cached = this.searchCache.get(cacheKey);
+        if (!cached) {
+            return null;
+        }
+        if (cached.expiresAt <= Date.now()) {
+            this.searchCache.delete(cacheKey);
+            return null;
+        }
+        return cloneResult(cached.value);
+    }
+    setCache(cacheKey, value) {
+        if (this.config.researchGraphCacheTtlMs <= 0) {
+            return;
+        }
+        const now = Date.now();
+        for (const [key, cached] of this.searchCache.entries()) {
+            if (cached.expiresAt <= now) {
+                this.searchCache.delete(key);
+            }
+        }
+        this.searchCache.set(cacheKey, {
+            value: cloneResult(value),
+            expiresAt: now + this.config.researchGraphCacheTtlMs
+        });
+        while (this.searchCache.size > this.config.researchGraphMaxCacheEntries) {
+            const oldestKey = this.searchCache.keys().next().value;
+            if (!oldestKey) {
+                break;
+            }
+            this.searchCache.delete(oldestKey);
+        }
+    }
+    async searchWithScholarScrape(query, limit) {
+        const result = await this.scholarService.searchKeywords({
+            query,
+            numResults: limit,
+            start: 0,
+            language: this.config.scholarLanguage
+        });
+        return result.papers.map((paper) => ({
+            provider: 'scholar_scrape',
+            providerId: paper.url ?? `scholar:${paper.title}`,
+            title: paper.title,
+            abstract: paper.abstract || null,
+            year: parseYear(paper.year),
+            venue: null,
+            doi: null,
+            url: paper.url,
+            citationCount: paper.citedByCount,
+            influentialCitationCount: 0,
+            referenceCount: 0,
+            authors: paper.authorsLine
+                .split(',')
+                .map((name) => ({ name: name.trim() }))
+                .filter((author) => author.name.length > 0),
+            openAccess: {
+                isOpenAccess: Boolean(paper.pdfUrl),
+                pdfUrl: paper.pdfUrl,
+                license: null
+            },
+            externalIds: {},
+            fieldsOfStudy: [],
+            score: 0.4,
+            sourceUrl: result.requestedUrl
+        }));
+    }
+}

package/dist/research/providers/crossref-client.js

@@ -0,0 +1,73 @@
+import { normalizeDoi, parseYear } from '../utils.js';
+const parseCrossrefYear = (item) => {
+    const fromIssued = item.issued?.['date-parts']?.[0]?.[0];
+    if (typeof fromIssued === 'number') {
+        return parseYear(fromIssued);
+    }
+    const fromPublished = item.published?.['date-parts']?.[0]?.[0];
+    if (typeof fromPublished === 'number') {
+        return parseYear(fromPublished);
+    }
+    return null;
+};
+const toPlainAbstract = (value) => {
+    if (!value) {
+        return null;
+    }
+    const stripped = value.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+    return stripped.length > 0 ? stripped : null;
+};
+export class CrossrefClient {
+    config;
+    httpClient;
+    constructor(config, httpClient) {
+        this.config = config;
+        this.httpClient = httpClient;
+    }
+    async searchWorks(query, limit) {
+        const url = new URL('/works', this.config.researchCrossrefBaseUrl);
+        url.searchParams.set('query.bibliographic', query);
+        url.searchParams.set('rows', String(limit));
+        const payload = await this.httpClient.fetchJson({
+            provider: 'crossref',
+            url,
+            headers: {
+                accept: 'application/json'
+            }
+        });
+        return (payload.message?.items ?? []).map((item) => {
+            const doi = normalizeDoi(item.DOI ?? null);
+            const linkPdf = (item.link ?? []).find((link) => (link['content-type'] ?? '').includes('pdf'))?.URL ?? null;
+            return {
+                provider: 'crossref',
+                providerId: doi ? `doi:${doi}` : `crossref:${item.URL ?? 'unknown'}`,
+                title: item.title?.[0] ?? 'Untitled',
+                abstract: toPlainAbstract(item.abstract),
+                year: parseCrossrefYear(item),
+                venue: item['container-title']?.[0] ?? null,
+                doi,
+                url: item.URL ?? null,
+                citationCount: item['is-referenced-by-count'] ?? 0,
+                influentialCitationCount: 0,
+                referenceCount: item.reference?.length ?? 0,
+                authors: (item.author ?? [])
+                    .map((author) => ({
+                    name: [author.given ?? '', author.family ?? ''].join(' ').trim(),
+                    authorId: author.ORCID?.replace('https://orcid.org/', '') ?? null
+                }))
+                    .filter((author) => author.name.length > 0),
+                openAccess: {
+                    isOpenAccess: Boolean(linkPdf),
+                    pdfUrl: linkPdf,
+                    license: item.license?.[0]?.URL ?? null
+                },
+                externalIds: {
+                    ...(doi ? { doi } : {})
+                },
+                fieldsOfStudy: item.subject ?? [],
+                score: item.score ?? 0.5,
+                sourceUrl: url.toString()
+            };
+        });
+    }
+}

package/dist/research/providers/openalex-client.js

@@ -0,0 +1,80 @@
+import { normalizeDoi, parseYear } from '../utils.js';
+const decodeInvertedAbstract = (inverted) => {
+    if (!inverted || Object.keys(inverted).length === 0) {
+        return null;
+    }
+    let max = 0;
+    for (const positions of Object.values(inverted)) {
+        for (const index of positions) {
+            if (index > max) {
+                max = index;
+            }
+        }
+    }
+    const words = new Array(max + 1).fill('');
+    for (const [token, positions] of Object.entries(inverted)) {
+        for (const index of positions) {
+            words[index] = token;
+        }
+    }
+    const text = words.join(' ').replace(/\s+/g, ' ').trim();
+    return text.length > 0 ? text : null;
+};
+export class OpenAlexClient {
+    config;
+    httpClient;
+    constructor(config, httpClient) {
+        this.config = config;
+        this.httpClient = httpClient;
+    }
+    async searchWorks(query, limit) {
+        const url = new URL('/works', this.config.researchOpenAlexBaseUrl);
+        url.searchParams.set('search', query);
+        url.searchParams.set('per-page', String(limit));
+        if (this.config.researchOpenAlexApiKey) {
+            url.searchParams.set('api_key', this.config.researchOpenAlexApiKey);
+        }
+        const payload = await this.httpClient.fetchJson({
+            provider: 'openalex',
+            url
+        });
+        return (payload.results ?? []).map((item) => {
+            const doi = normalizeDoi(item.ids?.doi ?? null);
+            return {
+                provider: 'openalex',
+                providerId: item.id ?? `openalex:${item.display_name ?? 'unknown'}`,
+                title: item.display_name ?? 'Untitled',
+                abstract: decodeInvertedAbstract(item.abstract_inverted_index),
+                year: parseYear(item.publication_year),
+                venue: item.primary_location?.source?.display_name ?? null,
+                doi,
+                url: item.primary_location?.landing_page_url ?? item.id ?? null,
+                citationCount: item.cited_by_count ?? 0,
+                influentialCitationCount: 0,
+                referenceCount: item.referenced_works_count ?? 0,
+                authors: (item.authorships ?? [])
+                    .map((auth) => ({
+                    name: auth.author?.display_name ?? '',
+                    authorId: auth.author?.id ?? null
+                }))
+                    .filter((author) => author.name.length > 0),
+                openAccess: {
+                    isOpenAccess: item.open_access?.is_oa ?? item.open_access?.any_repository_has_fulltext ?? Boolean(item.primary_location?.pdf_url),
+                    pdfUrl: item.primary_location?.pdf_url ?? item.open_access?.oa_url ?? null,
+                    license: item.primary_location?.license ?? item.open_access?.oa_status ?? null
+                },
+                externalIds: {
+                    ...(item.ids?.openalex ? { openalex: item.ids.openalex } : {}),
+                    ...(doi ? { doi } : {}),
+                    ...(item.ids?.pmid ? { pmid: item.ids.pmid } : {}),
+                    ...(item.ids?.pmcid ? { pmcid: item.ids.pmcid } : {})
+                },
+                fieldsOfStudy: (item.concepts ?? [])
+                    .map((concept) => concept.display_name ?? '')
+                    .filter((value) => value.length > 0),
+                score: item.relevance_score ?? 0.5,
+                sourceUrl: url.toString()
+            };
+        });
+    }
+}

package/dist/research/providers/semantic-scholar-client.js

@@ -0,0 +1,60 @@
+import { normalizeDoi, parseYear } from '../utils.js';
+export class SemanticScholarClient {
+    config;
+    httpClient;
+    constructor(config, httpClient) {
+        this.config = config;
+        this.httpClient = httpClient;
+    }
+    async searchWorks(query, limit) {
+        const url = new URL('/paper/search', this.config.researchSemanticScholarBaseUrl.endsWith('/')
+            ? this.config.researchSemanticScholarBaseUrl
+            : `${this.config.researchSemanticScholarBaseUrl}/`);
+        url.searchParams.set('query', query);
+        url.searchParams.set('limit', String(limit));
+        url.searchParams.set('fields', 'paperId,title,abstract,year,venue,externalIds,url,citationCount,influentialCitationCount,referenceCount,isOpenAccess,openAccessPdf,fieldsOfStudy,authors');
+        const headers = { accept: 'application/json' };
+        if (this.config.researchSemanticScholarApiKey) {
+            headers['x-api-key'] = this.config.researchSemanticScholarApiKey;
+        }
+        const payload = await this.httpClient.fetchJson({
+            provider: 'semantic_scholar',
+            url,
+            headers
+        });
+        return (payload.data ?? []).map((item) => {
+            const doi = normalizeDoi(item.externalIds?.DOI ?? null);
+            return {
+                provider: 'semantic_scholar',
+                providerId: item.paperId ?? `semantic:${item.title ?? 'unknown'}`,
+                title: item.title ?? 'Untitled',
+                abstract: item.abstract ?? null,
+                year: parseYear(item.year),
+                venue: item.venue ?? null,
+                doi,
+                url: item.url ?? null,
+                citationCount: item.citationCount ?? 0,
+                influentialCitationCount: item.influentialCitationCount ?? 0,
+                referenceCount: item.referenceCount ?? 0,
+                authors: (item.authors ?? [])
+                    .map((author) => ({
+                    name: author.name ?? '',
+                    authorId: author.authorId ?? null
+                }))
+                    .filter((author) => author.name.length > 0),
+                openAccess: {
+                    isOpenAccess: item.isOpenAccess ?? Boolean(item.openAccessPdf?.url),
+                    pdfUrl: item.openAccessPdf?.url ?? null,
+                    license: item.openAccessPdf?.license ?? null
+                },
+                externalIds: {
+                    ...(doi ? { doi } : {}),
+                    ...(item.externalIds ?? {})
+                },
+                fieldsOfStudy: item.fieldsOfStudy ?? [],
+                score: 0.7,
+                sourceUrl: url.toString()
+            };
+        });
+    }
+}

package/dist/research/research-service.js

@@ -0,0 +1,53 @@
+import { CitationService } from './citation-service.js';
+import { ExtractionService } from './extraction-service.js';
+import { LiteratureService } from './literature-service.js';
+import { IngestionService } from './ingestion-service.js';
+export class ResearchService {
+    config;
+    logger;
+    scholarService;
+    literatureService;
+    ingestionService;
+    extractionService;
+    citationService;
+    constructor(config, logger, scholarService) {
+        this.config = config;
+        this.logger = logger;
+        this.scholarService = scholarService;
+        this.literatureService = new LiteratureService(config, logger, scholarService);
+        this.ingestionService = new IngestionService(config, logger, this.literatureService);
+        this.extractionService = new ExtractionService();
+        this.citationService = new CitationService(this.literatureService);
+    }
+    static fromConfig(config, logger, scholarService) {
+        return new ResearchService(config, logger, scholarService);
+    }
+    async searchLiteratureGraph(input) {
+        return this.literatureService.searchGraph(input);
+    }
+    async resolveWorkByDoi(doi) {
+        return this.literatureService.resolveByDoi(doi);
+    }
+    ingestPaperFullText(input) {
+        return this.ingestionService.enqueueIngestion(input);
+    }
+    getIngestionStatus(jobId) {
+        return this.ingestionService.getJob(jobId);
+    }
+    getParsedDocument(documentId) {
+        return this.ingestionService.getDocument(documentId);
+    }
+    extractGranularPaperDetails(documentId, input) {
+        const document = this.ingestionService.getDocument(documentId);
+        return this.extractionService.extract(document, input);
+    }
+    suggestContextualCitations(input) {
+        return this.citationService.suggestContextualCitations(input);
+    }
+    buildReferenceList(input) {
+        return this.citationService.buildReferenceList(input);
+    }
+    validateManuscriptCitations(manuscriptText, references, options) {
+        return this.citationService.validateManuscriptCitations(manuscriptText, references, options);
+    }
+}

package/dist/research/types.js

@@ -0,0 +1 @@
+export {};