paper-search-cli 0.3.1 → 0.3.2

package/dist/core/handleToolCall.js

@@ -1,13 +1,11 @@
 import { parseToolArgs } from './schemas.js';
 import { PaperFactory } from '../models/Paper.js';
-import { TIMEOUTS } from '../config/constants.js';
-import { logDebug } from '../utils/Logger.js';
-import { searchMultipleSources } from '../services/MultiSourceSearchService.js';
-import { downloadWithFallback } from '../services/OpenAccessFallbackService.js';
-import { queryJournalMetrics } from '../services/JournalMetricsService.js';
-import CitationService from '../services/CitationService.js';
-import { withTimeout } from '../utils/SecurityUtils.js';
-import { getGenericSearchToolPlatform, getPlatformMetadata, isPlatformAlias, resolvePlatformId } from './platformMetadata.js';
+import { handleSemanticSnippets } from '../capabilities/body-snippet-search/handler.js';
+import { handleGetPaperCitations, handleGetPaperReferences } from '../capabilities/citation-expansion/handler.js';
+import { handleGenericSearch, handleGetPaperByDoi, handleSearchPapers } from '../capabilities/metadata-search/handler.js';
+import { handleJournalMetrics } from '../capabilities/journal-metrics/handler.js';
+import { handleDownloadPaper, handleDownloadWithFallback } from '../capabilities/pdf-discovery/handler.js';
+import { getGenericSearchToolPlatform, isPlatformAlias } from './platformMetadata.js';
 function jsonTextResponse(text) {
     return {
         content: [
@@ -18,526 +16,284 @@ function jsonTextResponse(text) {
         ]
     };
 }
-const DOI_LOOKUP_SOURCES = [
-    'crossref',
-    'openalex',
-    'unpaywall',
-    'pubmed',
-    'pmc',
-    'europepmc',
-    'core',
-    'webofscience',
-    'arxiv'
-];
-function parseJournalList(value) {
-    if (!value)
-        return [];
-    if (Array.isArray(value))
-        return value.map(item => String(item));
-    return String(value)
-        .split(/\r?\n|[,;；]/)
-        .map(item => item.trim())
-        .filter(Boolean);
-}
-function normalizeDoi(value) {
-    return value
-        .trim()
-        .replace(/^https?:\/\/(?:dx\.)?doi\.org\//i, '')
-        .toLowerCase();
-}
-function paperMatchesDoi(paper, doi) {
-    return normalizeDoi(paper.doi || '') === normalizeDoi(doi);
-}
-function resolveCitationTarget(args) {
-    if (args.paperId)
-        return args.paperId;
-    if (args.doi)
-        return `DOI:${args.doi}`;
-    if (args.arxivId)
-        return `ARXIV:${args.arxivId}`;
-    throw new Error('Provide paperId, doi, or arxivId');
-}
-function citationResponse(target, relation, papers) {
-    return {
-        target,
-        relation,
-        provider: 'semantic_scholar',
-        total: papers.length,
-        papers
-    };
-}
-async function handleGenericSearch(platform, args, searchers) {
-    const resolvedPlatform = resolvePlatformId(platform);
-    const searcher = searchers[resolvedPlatform];
-    if (!searcher) {
-        throw new Error(`Unsupported platform: ${platform}`);
-    }
-    const { query, ...searchOptions } = args;
-    const results = await searcher.search(query, searchOptions);
-    const displayName = getPlatformMetadata(platform)?.displayName || platform;
-    return jsonTextResponse(`Found ${results.length} ${displayName} papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
-}
-export async function handleToolCall(toolNameRaw, rawArgs, searchers) {
-    const toolName = toolNameRaw;
-    const args = parseToolArgs(toolName, rawArgs);
-    const genericSearchPlatform = getGenericSearchToolPlatform(toolNameRaw);
-    if (genericSearchPlatform) {
-        return handleGenericSearch(genericSearchPlatform, args, searchers);
-    }
-    switch (toolName) {
-        case 'search_papers': {
-            const { query, platform, sources, maxResults, year, author, journal, category, days, fetchDetails, fieldsOfStudy, sortBy, sortOrder } = args;
-            const results = [];
-            const searchOptions = {
-                maxResults,
-                year,
-                author,
-                journal,
-                category,
-                days,
-                fetchDetails,
-                fieldsOfStudy,
-                sortBy,
-                sortOrder
-            };
-            if (platform === 'all') {
-                const result = await searchMultipleSources(searchers, query, sources || 'all', searchOptions);
-                return jsonTextResponse(`Found ${result.total} papers across ${result.sources_used.length} source(s).\n\n${JSON.stringify(result, null, 2)}`);
-            }
-            else if (sources) {
-                const result = await searchMultipleSources(searchers, query, sources, searchOptions);
-                return jsonTextResponse(`Found ${result.total} papers across ${result.sources_used.length} source(s).\n\n${JSON.stringify(result, null, 2)}`);
-            }
-            else {
-                const resolvedPlatform = resolvePlatformId(platform);
-                const searcher = searchers[resolvedPlatform];
-                if (!searcher) {
-                    throw new Error(`Unsupported platform: ${platform}`);
-                }
-                const platformResults = await searcher.search(query, searchOptions);
-                results.push(...platformResults.map((paper) => PaperFactory.toDict(paper)));
-            }
-            return jsonTextResponse(`Found ${results.length} papers.\n\n${JSON.stringify(results, null, 2)}`);
+const TOOL_HANDLERS = {
+    search_papers: async (args, searchers) => handleSearchPapers(args, searchers),
+    search_arxiv: async (args, searchers) => {
+        const { query, maxResults, category, author, year, sortBy, sortOrder } = args;
+        const results = await searchers.arxiv.search(query, {
+            maxResults,
+            category,
+            author,
+            year,
+            sortBy,
+            sortOrder
+        });
+        return jsonTextResponse(`Found ${results.length} arXiv papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
+    },
+    search_webofscience: async (args, searchers) => {
+        const { query, maxResults, year, author, journal, sortBy, sortOrder } = args;
+        if (!process.env.WOS_API_KEY) {
+            throw new Error('Web of Science API key not configured. Please set WOS_API_KEY environment variable.');
         }
-        case 'search_arxiv': {
-            const { query, maxResults, category, author, year, sortBy, sortOrder } = args;
-            const results = await searchers.arxiv.search(query, {
-                maxResults,
-                category,
-                author,
-                year,
-                sortBy,
-                sortOrder
-            });
-            return jsonTextResponse(`Found ${results.length} arXiv papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
+        const results = await searchers.webofscience.search(query, {
+            maxResults,
+            year,
+            author,
+            journal,
+            sortBy,
+            sortOrder
+        });
+        return jsonTextResponse(`Found ${results.length} Web of Science papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
+    },
+    search_pubmed: async (args, searchers) => {
+        const { query, maxResults, year, author, journal, publicationType, sortBy } = args;
+        const results = await searchers.pubmed.search(query, {
+            maxResults,
+            year,
+            author,
+            journal,
+            publicationType,
+            sortBy
+        });
+        const rateStatus = searchers.pubmed.getRateLimiterStatus();
+        const apiKeyStatus = searchers.pubmed.hasApiKey() ? 'configured' : 'not configured';
+        const rateLimit = searchers.pubmed.hasApiKey() ? '10 requests/second' : '3 requests/second';
+        return jsonTextResponse(`Found ${results.length} PubMed papers.\n\nAPI Status: ${apiKeyStatus} (${rateLimit})\nRate Limiter: ${rateStatus.availableTokens}/${rateStatus.maxTokens} tokens available\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
+    },
+    search_biorxiv: async (args, searchers) => {
+        const { query, maxResults, days, category } = args;
+        const results = await searchers.biorxiv.search(query, {
+            maxResults,
+            days,
+            category
+        });
+        return jsonTextResponse(`Found ${results.length} bioRxiv papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
+    },
+    search_medrxiv: async (args, searchers) => {
+        const { query, maxResults, days, category } = args;
+        const results = await searchers.medrxiv.search(query, {
+            maxResults,
+            days,
+            category
+        });
+        return jsonTextResponse(`Found ${results.length} medRxiv papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
+    },
+    search_semantic_scholar: async (args, searchers) => {
+        const { query, maxResults, year, fieldsOfStudy } = args;
+        const results = await searchers.semantic.search(query, {
+            maxResults,
+            year,
+            fieldsOfStudy
+        });
+        const rateStatus = searchers.semantic.getRateLimiterStatus();
+        const apiKeyStatus = searchers.semantic.hasApiKey()
+            ? 'configured'
+            : 'not configured (using free tier)';
+        const rateLimit = searchers.semantic.hasApiKey() ? '200 requests/minute' : '20 requests/minute';
+        return jsonTextResponse(`Found ${results.length} Semantic Scholar papers.\n\nAPI Status: ${apiKeyStatus} (${rateLimit})\nRate Limiter: ${rateStatus.availableTokens}/${rateStatus.maxTokens} tokens available\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
+    },
+    search_semantic_snippets: async (args, searchers) => handleSemanticSnippets(args, searchers),
+    get_paper_citations: async (args) => handleGetPaperCitations(args),
+    get_paper_references: async (args) => handleGetPaperReferences(args),
+    search_iacr: async (args, searchers) => {
+        const { query, maxResults, fetchDetails } = args;
+        const results = await searchers.iacr.search(query, { maxResults, fetchDetails });
+        return jsonTextResponse(`Found ${results.length} IACR ePrint papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
+    },
+    download_paper: async (args, searchers) => handleDownloadPaper(args, searchers),
+    download_with_fallback: async (args, searchers) => handleDownloadWithFallback(args, searchers),
+    query_journal_metrics: async (args) => handleJournalMetrics(args),
+    search_google_scholar: async (args, searchers) => {
+        const { query, maxResults, yearLow, yearHigh, author } = args;
+        const results = await searchers.googlescholar.search(query, {
+            maxResults,
+            yearLow,
+            yearHigh,
+            author
+        });
+        return jsonTextResponse(`Found ${results.length} Google Scholar papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
+    },
+    get_paper_by_doi: async (args, searchers) => handleGetPaperByDoi(args, searchers),
+    search_scihub: async (args, searchers) => {
+        const { doiOrUrl, downloadPdf, savePath } = args;
+        const resolvedSavePath = savePath || './downloads';
+        const results = await searchers.scihub.search(doiOrUrl);
+        if (results.length === 0) {
+            return jsonTextResponse(`No paper found on Sci-Hub for: ${doiOrUrl}`);
         }
-        case 'search_webofscience': {
-            const { query, maxResults, year, author, journal, sortBy, sortOrder } = args;
-            if (!process.env.WOS_API_KEY) {
-                throw new Error('Web of Science API key not configured. Please set WOS_API_KEY environment variable.');
-            }
-            const results = await searchers.webofscience.search(query, {
-                maxResults,
-                year,
-                author,
-                journal,
-                sortBy,
-                sortOrder
-            });
-            return jsonTextResponse(`Found ${results.length} Web of Science papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
-        }
-        case 'search_pubmed': {
-            const { query, maxResults, year, author, journal, publicationType, sortBy } = args;
-            const results = await searchers.pubmed.search(query, {
-                maxResults,
-                year,
-                author,
-                journal,
-                publicationType,
-                sortBy
-            });
-            const rateStatus = searchers.pubmed.getRateLimiterStatus();
-            const apiKeyStatus = searchers.pubmed.hasApiKey() ? 'configured' : 'not configured';
-            const rateLimit = searchers.pubmed.hasApiKey() ? '10 requests/second' : '3 requests/second';
-            return jsonTextResponse(`Found ${results.length} PubMed papers.\n\nAPI Status: ${apiKeyStatus} (${rateLimit})\nRate Limiter: ${rateStatus.availableTokens}/${rateStatus.maxTokens} tokens available\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
-        }
-        case 'search_biorxiv': {
-            const { query, maxResults, days, category } = args;
-            const results = await searchers.biorxiv.search(query, {
-                maxResults,
-                days,
-                category
-            });
-            return jsonTextResponse(`Found ${results.length} bioRxiv papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
-        }
-        case 'search_medrxiv': {
-            const { query, maxResults, days, category } = args;
-            const results = await searchers.medrxiv.search(query, {
-                maxResults,
-                days,
-                category
-            });
-            return jsonTextResponse(`Found ${results.length} medRxiv papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
-        }
-        case 'search_semantic_scholar': {
-            const { query, maxResults, year, fieldsOfStudy } = args;
-            const results = await searchers.semantic.search(query, {
-                maxResults,
-                year,
-                fieldsOfStudy
-            });
-            const rateStatus = searchers.semantic.getRateLimiterStatus();
-            const apiKeyStatus = searchers.semantic.hasApiKey()
-                ? 'configured'
-                : 'not configured (using free tier)';
-            const rateLimit = searchers.semantic.hasApiKey() ? '200 requests/minute' : '20 requests/minute';
-            return jsonTextResponse(`Found ${results.length} Semantic Scholar papers.\n\nAPI Status: ${apiKeyStatus} (${rateLimit})\nRate Limiter: ${rateStatus.availableTokens}/${rateStatus.maxTokens} tokens available\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
-        }
-        case 'search_semantic_snippets': {
-            const results = await searchers.semantic.searchSnippets(args);
-            const bodyCount = results.filter(result => result.snippet.snippetKind === 'body').length;
-            return jsonTextResponse(`Found ${results.length} Semantic Scholar snippet(s), including ${bodyCount} body snippet(s).\n\n${JSON.stringify(results, null, 2)}`);
-        }
-        case 'get_paper_citations': {
-            const target = resolveCitationTarget(args);
-            const service = new CitationService();
-            const papers = await service.getCitations(target, args.limit);
-            const result = citationResponse(target, 'citations', papers);
-            return jsonTextResponse(`Found ${papers.length} citing paper(s).\n\n${JSON.stringify(result, null, 2)}`);
-        }
-        case 'get_paper_references': {
-            const target = resolveCitationTarget(args);
-            const service = new CitationService();
-            const papers = await service.getReferences(target, args.limit);
-            const result = citationResponse(target, 'references', papers);
-            return jsonTextResponse(`Found ${papers.length} cited reference(s).\n\n${JSON.stringify(result, null, 2)}`);
-        }
-        case 'search_iacr': {
-            const { query, maxResults, fetchDetails } = args;
-            const results = await searchers.iacr.search(query, { maxResults, fetchDetails });
-            return jsonTextResponse(`Found ${results.length} IACR ePrint papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
-        }
-        case 'download_paper': {
-            const { paperId, platform, savePath } = args;
-            const resolvedSavePath = savePath || './downloads';
-            const resolvedPlatform = resolvePlatformId(platform);
-            const searcher = searchers[resolvedPlatform];
-            if (!searcher) {
-                throw new Error(`Unsupported platform for download: ${platform}`);
-            }
-            if (!searcher.getCapabilities().download) {
-                const result = await downloadWithFallback(searchers, {
-                    source: resolvedPlatform,
-                    paperId,
-                    doi: paperId,
-                    savePath: resolvedSavePath,
-                    useSciHub: true
-                });
-                if (result.status === 'ok') {
-                    return jsonTextResponse(`PDF downloaded successfully via fallback to: ${result.path}\n\n${JSON.stringify(result, null, 2)}`);
-                }
-                return jsonTextResponse(`PDF download failed via fallback.\n\n${JSON.stringify(result, null, 2)}`);
-            }
+        const paper = results[0];
+        let responseText = `Found paper on Sci-Hub:\n\n${JSON.stringify(PaperFactory.toDict(paper), null, 2)}`;
+        if (downloadPdf && paper.pdfUrl) {
             try {
-                const filePath = await searcher.downloadPdf(paperId, { savePath: resolvedSavePath });
-                return jsonTextResponse(`PDF downloaded successfully to: ${filePath}`);
+                const filePath = await searchers.scihub.downloadPdf(doiOrUrl, { savePath: resolvedSavePath });
+                responseText += `\n\nPDF downloaded successfully to: ${filePath}`;
             }
-            catch (error) {
-                const result = await downloadWithFallback(searchers, {
-                    source: resolvedPlatform,
-                    paperId,
-                    doi: paperId,
-                    savePath: resolvedSavePath,
-                    useSciHub: true
-                });
-                if (result.status === 'ok') {
-                    return jsonTextResponse(`Primary download failed; PDF downloaded successfully via fallback to: ${result.path}\n\n${JSON.stringify(result, null, 2)}`);
-                }
-                throw error;
+            catch (downloadError) {
+                responseText += `\n\nFailed to download PDF: ${downloadError.message}`;
             }
         }
-        case 'download_with_fallback': {
-            const result = await downloadWithFallback(searchers, args);
-            return jsonTextResponse(`Download with fallback ${result.status}.\n\n${JSON.stringify(result, null, 2)}`);
+        return jsonTextResponse(responseText);
+    },
+    check_scihub_mirrors: async (args, searchers) => {
+        const { forceCheck } = args;
+        if (forceCheck) {
+            await searchers.scihub.forceHealthCheck();
         }
-        case 'query_journal_metrics': {
-            const { readFileSync } = await import('fs');
-            const journals = [
-                ...parseJournalList(args.journal),
-                ...parseJournalList(args.journals),
-                ...(args.file
-                    ? readFileSync(String(args.file), 'utf8')
-                        .split(/\r?\n/)
-                        .map(line => line.trim())
-                        .filter(line => line && !line.startsWith('#'))
-                    : [])
-            ];
-            const rows = await queryJournalMetrics({ journals, includeRaw: args.includeRaw });
-            const found = rows.filter(row => row.status === 'found').length;
-            return jsonTextResponse(`Found journal metrics for ${found}/${rows.length} journal(s).\n\n${JSON.stringify(rows, null, 2)}`);
+        const mirrorStatus = searchers.scihub.getMirrorStatus();
+        return jsonTextResponse(`Sci-Hub Mirror Status:\n\n${JSON.stringify(mirrorStatus, null, 2)}`);
+    },
+    search_sciencedirect: async (args, searchers) => {
+        const { query, maxResults, year, author, journal, openAccess } = args;
+        if (!process.env.ELSEVIER_API_KEY) {
+            throw new Error('Elsevier API key not configured. Please set ELSEVIER_API_KEY environment variable.');
         }
-        case 'search_google_scholar': {
-            const { query, maxResults, yearLow, yearHigh, author } = args;
-            const results = await searchers.googlescholar.search(query, {
-                maxResults,
-                yearLow,
-                yearHigh,
-                author
-            });
-            return jsonTextResponse(`Found ${results.length} Google Scholar papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
+        const results = await searchers.sciencedirect.search(query, {
+            maxResults,
+            year,
+            author,
+            journal,
+            openAccess
+        });
+        return jsonTextResponse(`Found ${results.length} ScienceDirect papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
+    },
+    search_springer: async (args, searchers) => {
+        const { query, maxResults, year, author, journal, subject, openAccess, type } = args;
+        if (!process.env.SPRINGER_API_KEY) {
+            throw new Error('Springer API key not configured. Please set SPRINGER_API_KEY environment variable.');
         }
-        case 'get_paper_by_doi': {
-            const { doi, platform } = args;
-            const results = [];
-            const sourceResults = {};
-            const errors = {};
-            const failedSources = [];
-            if (platform === 'all') {
-                const selected = DOI_LOOKUP_SOURCES.filter(source => source in searchers);
-                const settled = await Promise.allSettled(selected.map(async (source) => {
-                    const searcher = searchers[source];
-                    const paper = await withTimeout(searcher.getPaperByDoi(doi), TIMEOUTS.SOURCE_TASK, `${source} DOI lookup timed out after ${TIMEOUTS.SOURCE_TASK}ms`);
-                    return { source, paper };
-                }));
-                for (let i = 0; i < settled.length; i += 1) {
-                    const source = selected[i];
-                    const result = settled[i];
-                    if (result.status === 'rejected') {
-                        sourceResults[source] = 0;
-                        errors[source] = result.reason?.message || String(result.reason);
-                        failedSources.push(source);
-                        logDebug(`Error getting paper by DOI from ${source}:`, result.reason);
-                        continue;
-                    }
-                    const paper = result.value.paper;
-                    if (!paper) {
-                        sourceResults[source] = 0;
-                        continue;
-                    }
-                    if (!paperMatchesDoi(paper, doi)) {
-                        sourceResults[source] = 0;
-                        errors[source] = `Returned DOI ${paper.doi || '(missing)'} did not match requested DOI ${doi}`;
-                        failedSources.push(source);
-                        continue;
-                    }
-                    sourceResults[source] = 1;
-                    results.push(PaperFactory.toDict(paper));
-                }
-            }
-            else {
-                const searcher = searchers[resolvePlatformId(platform)];
-                if (!searcher) {
-                    throw new Error(`Unsupported platform: ${platform}`);
-                }
-                const paper = await searcher.getPaperByDoi(doi);
-                if (paper) {
-                    results.push(PaperFactory.toDict(paper));
-                }
-            }
-            if (results.length === 0) {
-                if (platform === 'all') {
-                    const result = {
-                        doi,
-                        sources_requested: 'all',
-                        sources_used: DOI_LOOKUP_SOURCES.filter(source => source in searchers),
-                        source_results: sourceResults,
-                        errors,
-                        failed_sources: failedSources,
-                        warnings: failedSources.map(source => `${source}: ${errors[source]}`),
-                        total: 0,
-                        papers: []
-                    };
-                    return jsonTextResponse(`No paper found with DOI: ${doi}\n\n${JSON.stringify(result, null, 2)}`);
-                }
-                return jsonTextResponse(`No paper found with DOI: ${doi}`);
-            }
-            if (platform === 'all') {
-                const result = {
-                    doi,
-                    sources_requested: 'all',
-                    sources_used: DOI_LOOKUP_SOURCES.filter(source => source in searchers),
-                    source_results: sourceResults,
-                    errors,
-                    failed_sources: failedSources,
-                    warnings: failedSources.map(source => `${source}: ${errors[source]}`),
-                    total: results.length,
-                    papers: results
-                };
-                return jsonTextResponse(`Found ${results.length} paper(s) with DOI ${doi} across ${result.sources_used.length} source(s).\n\n${JSON.stringify(result, null, 2)}`);
-            }
-            return jsonTextResponse(`Found ${results.length} paper(s) with DOI ${doi}:\n\n${JSON.stringify(results, null, 2)}`);
-        }
-        case 'search_scihub': {
-            const { doiOrUrl, downloadPdf, savePath } = args;
-            const resolvedSavePath = savePath || './downloads';
-            const results = await searchers.scihub.search(doiOrUrl);
-            if (results.length === 0) {
-                return jsonTextResponse(`No paper found on Sci-Hub for: ${doiOrUrl}`);
-            }
-            const paper = results[0];
-            let responseText = `Found paper on Sci-Hub:\n\n${JSON.stringify(PaperFactory.toDict(paper), null, 2)}`;
-            if (downloadPdf && paper.pdfUrl) {
-                try {
-                    const filePath = await searchers.scihub.downloadPdf(doiOrUrl, { savePath: resolvedSavePath });
-                    responseText += `\n\nPDF downloaded successfully to: ${filePath}`;
-                }
-                catch (downloadError) {
-                    responseText += `\n\nFailed to download PDF: ${downloadError.message}`;
-                }
-            }
-            return jsonTextResponse(responseText);
-        }
-        case 'check_scihub_mirrors': {
-            const { forceCheck } = args;
-            if (forceCheck) {
-                await searchers.scihub.forceHealthCheck();
-            }
-            const mirrorStatus = searchers.scihub.getMirrorStatus();
-            return jsonTextResponse(`Sci-Hub Mirror Status:\n\n${JSON.stringify(mirrorStatus, null, 2)}`);
-        }
-        case 'search_sciencedirect': {
-            const { query, maxResults, year, author, journal, openAccess } = args;
-            if (!process.env.ELSEVIER_API_KEY) {
-                throw new Error('Elsevier API key not configured. Please set ELSEVIER_API_KEY environment variable.');
-            }
-            const results = await searchers.sciencedirect.search(query, {
-                maxResults,
-                year,
-                author,
-                journal,
-                openAccess
-            });
-            return jsonTextResponse(`Found ${results.length} ScienceDirect papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
-        }
-        case 'search_springer': {
-            const { query, maxResults, year, author, journal, subject, openAccess, type } = args;
-            if (!process.env.SPRINGER_API_KEY) {
-                throw new Error('Springer API key not configured. Please set SPRINGER_API_KEY environment variable.');
-            }
-            const results = await searchers.springer.search(query, {
-                maxResults,
-                year,
-                author,
-                journal,
-                subject,
-                openAccess,
-                type
-            });
-            return jsonTextResponse(`Found ${results.length} Springer papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
-        }
-        case 'search_wiley': {
-            return jsonTextResponse(`DEPRECATED: Wiley TDM API does not support keyword search.\n\n` +
-                `To access Wiley content:\n` +
-                `1. Use search_crossref to find Wiley articles (filter by publisher if needed)\n` +
-                `2. Use download_paper with platform="wiley" and the DOI to download the PDF\n\n` +
-                `Example: download_paper(paperId="10.1111/jtsb.12390", platform="wiley")`);
+        const results = await searchers.springer.search(query, {
+            maxResults,
+            year,
+            author,
+            journal,
+            subject,
+            openAccess,
+            type
+        });
+        return jsonTextResponse(`Found ${results.length} Springer papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
+    },
+    search_wiley: async () => jsonTextResponse(`DEPRECATED: Wiley TDM API does not support keyword search.\n\n` +
+        `To access Wiley content:\n` +
+        `1. Use search_crossref to find Wiley articles (filter by publisher if needed)\n` +
+        `2. Use download_paper with platform="wiley" and the DOI to download the PDF\n\n` +
+        `Example: download_paper(paperId="10.1111/jtsb.12390", platform="wiley")`),
+    search_scopus: async (args, searchers) => {
+        const { query, maxResults, year, author, journal, affiliation, subject, openAccess, documentType } = args;
+        if (!process.env.ELSEVIER_API_KEY) {
+            throw new Error('Elsevier API key not configured. Please set ELSEVIER_API_KEY environment variable.');
         }
-        case 'search_scopus': {
-            const { query, maxResults, year, author, journal, affiliation, subject, openAccess, documentType } = args;
-            if (!process.env.ELSEVIER_API_KEY) {
-                throw new Error('Elsevier API key not configured. Please set ELSEVIER_API_KEY environment variable.');
-            }
-            const results = await searchers.scopus.search(query, {
-                maxResults,
-                year,
-                author,
-                journal,
-                affiliation,
-                subject,
-                openAccess,
-                documentType
-            });
-            return jsonTextResponse(`Found ${results.length} Scopus papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
-        }
-        case 'search_crossref': {
-            const { query, maxResults, year, author, sortBy, sortOrder } = args;
-            const results = await searchers.crossref.search(query, {
-                maxResults,
-                year,
-                author,
-                sortBy,
-                sortOrder
-            });
-            return jsonTextResponse(`Found ${results.length} Crossref papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
-        }
-        case 'search_openalex': {
-            const { query, maxResults, year } = args;
-            const results = await searchers.openalex.search(query, { maxResults, year });
-            return jsonTextResponse(`Found ${results.length} OpenAlex papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
-        }
-        case 'search_unpaywall': {
-            const { query, maxResults } = args;
-            const results = await searchers.unpaywall.search(query, { maxResults });
-            return jsonTextResponse(`Found ${results.length} Unpaywall record(s).\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
-        }
-        case 'search_pmc': {
-            const { query, maxResults, year } = args;
-            const results = await searchers.pmc.search(query, { maxResults, year });
-            return jsonTextResponse(`Found ${results.length} PMC papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
-        }
-        case 'search_europepmc': {
-            const { query, maxResults, year } = args;
-            const results = await searchers.europepmc.search(query, { maxResults, year });
-            return jsonTextResponse(`Found ${results.length} Europe PMC papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
-        }
-        case 'search_core': {
-            const { query, maxResults, year } = args;
-            const results = await searchers.core.search(query, { maxResults, year });
-            return jsonTextResponse(`Found ${results.length} CORE papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
-        }
-        case 'search_openaire': {
-            const { query, maxResults, year } = args;
-            const results = await searchers.openaire.search(query, { maxResults, year });
-            return jsonTextResponse(`Found ${results.length} OpenAIRE papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
-        }
-        case 'get_platform_status': {
-            const { validate } = args;
-            const statusInfo = [];
-            for (const [platformName, searcher] of Object.entries(searchers)) {
-                if (isPlatformAlias(platformName))
-                    continue;
-                const capabilities = searcher.getCapabilities();
-                const hasApiKey = searcher.hasApiKey();
-                let apiKeyStatus = 'not_required';
-                if (capabilities.requiresApiKey) {
-                    if (hasApiKey) {
-                        if (validate) {
-                            try {
-                                const isValid = await searcher.validateApiKey();
-                                apiKeyStatus = isValid ? 'valid' : 'invalid';
-                            }
-                            catch {
-                                apiKeyStatus = 'unknown';
-                            }
+        const results = await searchers.scopus.search(query, {
+            maxResults,
+            year,
+            author,
+            journal,
+            affiliation,
+            subject,
+            openAccess,
+            documentType
+        });
+        return jsonTextResponse(`Found ${results.length} Scopus papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
+    },
+    search_crossref: async (args, searchers) => {
+        const { query, maxResults, year, author, sortBy, sortOrder } = args;
+        const results = await searchers.crossref.search(query, {
+            maxResults,
+            year,
+            author,
+            sortBy,
+            sortOrder
+        });
+        return jsonTextResponse(`Found ${results.length} Crossref papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
+    },
+    search_openalex: async (args, searchers) => {
+        const { query, maxResults, year } = args;
+        const results = await searchers.openalex.search(query, { maxResults, year });
+        return jsonTextResponse(`Found ${results.length} OpenAlex papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
+    },
+    search_unpaywall: async (args, searchers) => {
+        const { query, maxResults } = args;
+        const results = await searchers.unpaywall.search(query, { maxResults });
+        return jsonTextResponse(`Found ${results.length} Unpaywall record(s).\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
+    },
+    search_pmc: async (args, searchers) => {
+        const { query, maxResults, year } = args;
+        const results = await searchers.pmc.search(query, { maxResults, year });
+        return jsonTextResponse(`Found ${results.length} PMC papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
+    },
+    search_europepmc: async (args, searchers) => {
+        const { query, maxResults, year } = args;
+        const results = await searchers.europepmc.search(query, { maxResults, year });
+        return jsonTextResponse(`Found ${results.length} Europe PMC papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
+    },
+    search_core: async (args, searchers) => {
+        const { query, maxResults, year } = args;
+        const results = await searchers.core.search(query, { maxResults, year });
+        return jsonTextResponse(`Found ${results.length} CORE papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
+    },
+    search_openaire: async (args, searchers) => {
+        const { query, maxResults, year } = args;
+        const results = await searchers.openaire.search(query, { maxResults, year });
+        return jsonTextResponse(`Found ${results.length} OpenAIRE papers.\n\n${JSON.stringify(results.map((paper) => PaperFactory.toDict(paper)), null, 2)}`);
+    },
+    get_platform_status: async (args, searchers) => {
+        const { validate } = args;
+        const statusInfo = [];
+        for (const [platformName, searcher] of Object.entries(searchers)) {
+            if (isPlatformAlias(platformName))
+                continue;
+            const capabilities = searcher.getCapabilities();
+            const hasApiKey = searcher.hasApiKey();
+            let apiKeyStatus = 'not_required';
+            if (capabilities.requiresApiKey) {
+                if (hasApiKey) {
+                    if (validate) {
+                        try {
+                            const isValid = await searcher.validateApiKey();
+                            apiKeyStatus = isValid ? 'valid' : 'invalid';
                         }
-                        else {
-                            apiKeyStatus = 'configured';
+                        catch {
+                            apiKeyStatus = 'unknown';
                         }
                     }
                     else {
-                        apiKeyStatus = 'missing';
+                        apiKeyStatus = 'configured';
                     }
                 }
-                let additionalInfo = {};
-                if (platformName === 'scihub') {
-                    const mirrorStatus = searchers.scihub.getMirrorStatus();
-                    additionalInfo = {
-                        mirrorCount: mirrorStatus.length,
-                        workingMirrors: mirrorStatus.filter(m => m.status === 'Working').length
-                    };
+                else {
+                    apiKeyStatus = 'missing';
                 }
-                statusInfo.push({
-                    platform: platformName,
-                    baseUrl: searcher.getBaseUrl(),
-                    capabilities,
-                    apiKeyStatus,
-                    ...additionalInfo
-                });
             }
-            return jsonTextResponse(`Platform Status:\n\n${JSON.stringify(statusInfo, null, 2)}`);
+            let additionalInfo = {};
+            if (platformName === 'scihub') {
+                const mirrorStatus = searchers.scihub.getMirrorStatus();
+                additionalInfo = {
+                    mirrorCount: mirrorStatus.length,
+                    workingMirrors: mirrorStatus.filter(m => m.status === 'Working').length
+                };
+            }
+            statusInfo.push({
+                platform: platformName,
+                baseUrl: searcher.getBaseUrl(),
+                capabilities,
+                apiKeyStatus,
+                ...additionalInfo
+            });
         }
-        default:
-            throw new Error(`Unknown tool: ${toolNameRaw}`);
+        return jsonTextResponse(`Platform Status:\n\n${JSON.stringify(statusInfo, null, 2)}`);
+    }
+};
+export const TOOL_HANDLER_NAMES = Object.keys(TOOL_HANDLERS).sort();
+export async function handleToolCall(toolNameRaw, rawArgs, searchers) {
+    const toolName = toolNameRaw;
+    const args = parseToolArgs(toolName, rawArgs);
+    const genericSearchPlatform = getGenericSearchToolPlatform(toolNameRaw);
+    if (genericSearchPlatform) {
+        return handleGenericSearch(genericSearchPlatform, args, searchers);
+    }
+    const handler = TOOL_HANDLERS[toolNameRaw];
+    if (!handler) {
+        throw new Error(`Unknown tool: ${toolNameRaw}`);
     }
+    return handler(args, searchers);
 }
 //# sourceMappingURL=handleToolCall.js.map