@cyanheads/pubmed-mcp-server 1.0.12

package/dist/mcp-server/tools/getPubMedArticleConnections/logic/citationFormatter.js

@@ -0,0 +1,288 @@
+/**
+ * @fileoverview Handles citation formatting for the getPubMedArticleConnections tool.
+ * Fetches article details using EFetch and formats them into various citation styles.
+ * @module src/mcp-server/tools/getPubMedArticleConnections/logic/citationFormatter
+ */
+import { ncbiService } from "../../../../services/NCBI/ncbiService.js";
+import { logger, requestContextService, } from "../../../../utils/index.js";
+import { extractAuthors, extractDoi, extractJournalInfo, extractPmid, getText, } from "../../../../utils/parsing/ncbi-parsing/index.js";
+// Main handler for citation formats
+export async function handleCitationFormats(input, outputData, context) {
+    const eFetchParams = {
+        db: "pubmed",
+        id: input.sourcePmid,
+        retmode: "xml",
+        // Omitting rettype to hopefully get the fullest XML record by default
+    };
+    const eFetchBaseUrl = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi";
+    const searchParamsString = new URLSearchParams(eFetchParams).toString();
+    outputData.eUtilityUrl = `${eFetchBaseUrl}?${searchParamsString}`;
+    const eFetchResult = await ncbiService.eFetch(eFetchParams, context);
+    if (!eFetchResult?.PubmedArticleSet?.PubmedArticle?.[0]) {
+        outputData.message =
+            "Could not retrieve article details for citation formatting.";
+        logger.warning(outputData.message, context);
+        return;
+    }
+    const article = eFetchResult.PubmedArticleSet.PubmedArticle[0];
+    if (input.citationStyles?.includes("ris")) {
+        outputData.citations.ris = formatAsRIS(article, context);
+    }
+    if (input.citationStyles?.includes("bibtex")) {
+        outputData.citations.bibtex = formatAsBibTeX(article, context);
+    }
+    if (input.citationStyles?.includes("apa_string")) {
+        outputData.citations.apa_string = formatAsAPA(article, context);
+    }
+    if (input.citationStyles?.includes("mla_string")) {
+        outputData.citations.mla_string = formatAsMLA(article, context);
+    }
+    outputData.retrievedCount = 1;
+}
+// --- Citation Formatting Helper Functions ---
+function formatAsRIS(article, context) {
+    const medlineCitation = article.MedlineCitation;
+    const articleDetails = medlineCitation?.Article;
+    const pmid = extractPmid(medlineCitation);
+    logger.debug("Formatting RIS for article", requestContextService.createRequestContext({ ...context, pmid }));
+    if (!articleDetails)
+        return "TY  - ERROR\nTI  - Article details not found\nER  - \n";
+    const authors = extractAuthors(articleDetails.AuthorList);
+    const journalInfo = extractJournalInfo(articleDetails.Journal, medlineCitation);
+    const title = getText(articleDetails.ArticleTitle);
+    const doi = extractDoi(articleDetails);
+    let risString = "TY  - JOUR\n";
+    authors.forEach((author) => {
+        if (author.lastName && author.firstName) {
+            risString += `AU  - ${author.lastName}, ${author.firstName}\n`;
+        }
+        else if (author.lastName) {
+            // Handle collective name or incomplete author
+            risString += `AU  - ${author.lastName}\n`;
+        }
+    });
+    risString += `TI  - ${title || "N/A"}\n`;
+    risString += `JO  - ${journalInfo?.title || "N/A"}\n`;
+    risString += `VL  - ${journalInfo?.volume || ""}\n`;
+    risString += `IS  - ${journalInfo?.issue || ""}\n`;
+    if (journalInfo?.pages) {
+        const pages = journalInfo.pages.split("-");
+        risString += `SP  - ${pages[0] || ""}\n`;
+        if (pages.length > 1)
+            risString += `EP  - ${pages[1] || ""}\n`;
+    }
+    risString += `PY  - ${journalInfo?.publicationDate?.year || ""}\n`;
+    if (doi)
+        risString += `DO  - ${doi}\n`;
+    if (pmid)
+        risString += `UR  - https://pubmed.ncbi.nlm.nih.gov/${pmid}\n`;
+    risString += "ER  - \n";
+    return risString;
+}
+function formatAsBibTeX(article, context) {
+    const medlineCitation = article.MedlineCitation;
+    const articleDetails = medlineCitation?.Article;
+    const pmid = extractPmid(medlineCitation);
+    logger.debug("Formatting BibTeX for article", requestContextService.createRequestContext({ ...context, pmid }));
+    if (!articleDetails)
+        return `@article{ERROR_ArticleNotFound${pmid || ""},\n  title = {Article details not found}\n}\n`;
+    const parsedAuthors = extractAuthors(articleDetails.AuthorList);
+    const journalInfo = extractJournalInfo(articleDetails.Journal, medlineCitation);
+    const title = getText(articleDetails.ArticleTitle) || "N/A";
+    const doi = extractDoi(articleDetails);
+    const authorsBibtex = parsedAuthors
+        .map((author) => {
+        if (author.lastName && author.firstName)
+            return `${author.lastName}, ${author.firstName}`;
+        if (author.lastName)
+            return `{${author.lastName}}`; // For collective names or single names
+        return "";
+    })
+        .filter(Boolean)
+        .join(" and ");
+    const year = journalInfo?.publicationDate?.year || "ND";
+    const firstAuthorLastName = parsedAuthors[0]?.lastName?.replace(/\s+/g, "") || "Unknown";
+    const bibKey = `${firstAuthorLastName}${year}`;
+    let bibtexString = `@article{${bibKey},\n`;
+    if (authorsBibtex)
+        bibtexString += `  author    = {${authorsBibtex}},\n`;
+    bibtexString += `  title     = {${title}},\n`;
+    bibtexString += `  journal   = {${journalInfo?.title || "N/A"}},\n`;
+    if (journalInfo?.publicationDate?.year)
+        bibtexString += `  year      = {${journalInfo.publicationDate.year}},\n`;
+    if (journalInfo?.volume)
+        bibtexString += `  volume    = {${journalInfo.volume}},\n`;
+    if (journalInfo?.issue)
+        bibtexString += `  number    = {${journalInfo.issue}},\n`;
+    if (journalInfo?.pages)
+        bibtexString += `  pages     = {${journalInfo.pages.replace("-", "--")}},\n`;
+    if (journalInfo?.publicationDate?.month)
+        bibtexString += `  month     = {${journalInfo.publicationDate.month.toLowerCase()}},\n`;
+    if (doi)
+        bibtexString += `  doi       = {${doi}},\n`;
+    if (pmid)
+        bibtexString += `  pmid      = {${pmid}}\n`;
+    bibtexString += `}\n`;
+    return bibtexString;
+}
+function formatAsAPA(article, context) {
+    const medlineCitation = article.MedlineCitation;
+    const articleDetails = medlineCitation?.Article;
+    const pmid = extractPmid(medlineCitation);
+    logger.debug("Formatting APA for article", requestContextService.createRequestContext({ ...context, pmid }));
+    if (!articleDetails)
+        return "Article details not found.";
+    const parsedAuthors = extractAuthors(articleDetails.AuthorList);
+    const journalInfo = extractJournalInfo(articleDetails.Journal, medlineCitation);
+    const titleText = getText(articleDetails.ArticleTitle) || "N/A";
+    const doi = extractDoi(articleDetails);
+    let authorsString = "N/A";
+    if (parsedAuthors.length > 0) {
+        if (parsedAuthors.length <= 20) {
+            authorsString = parsedAuthors
+                .map((author) => {
+                if (author.lastName && author.firstName) {
+                    const initials = author.firstName
+                        .split(/\s+|-/)
+                        .map((namePart) => namePart.charAt(0).toUpperCase() + ".")
+                        .join("");
+                    return `${author.lastName}, ${initials}`;
+                }
+                if (author.lastName)
+                    return author.lastName; // Collective name
+                return "";
+            })
+                .filter(Boolean)
+                .join(", ");
+            if (parsedAuthors.length > 1) {
+                const lastCommaIndex = authorsString.lastIndexOf(", ");
+                if (lastCommaIndex !== -1) {
+                    authorsString =
+                        authorsString.substring(0, lastCommaIndex) +
+                            " & " +
+                            authorsString.substring(lastCommaIndex + 2);
+                }
+            }
+        }
+        else {
+            const first19 = parsedAuthors
+                .slice(0, 19)
+                .map((author) => {
+                if (author.lastName && author.firstName) {
+                    const initials = author.firstName
+                        .split(/\s+|-/)
+                        .map((namePart) => namePart.charAt(0).toUpperCase() + ".")
+                        .join("");
+                    return `${author.lastName}, ${initials}`;
+                }
+                if (author.lastName)
+                    return author.lastName;
+                return "";
+            })
+                .filter(Boolean)
+                .join(", ");
+            const lastAuthor = parsedAuthors[parsedAuthors.length - 1];
+            let lastAuthorString = "";
+            if (lastAuthor.lastName && lastAuthor.firstName) {
+                const initials = lastAuthor.firstName
+                    .split(/\s+|-/)
+                    .map((namePart) => namePart.charAt(0).toUpperCase() + ".")
+                    .join("");
+                lastAuthorString = `${lastAuthor.lastName}, ${initials}`;
+            }
+            else if (lastAuthor.lastName) {
+                lastAuthorString = lastAuthor.lastName;
+            }
+            authorsString = `${first19}, ..., ${lastAuthorString}`;
+        }
+    }
+    const year = journalInfo?.publicationDate?.year || "n.d.";
+    const apaTitle = titleText.charAt(0).toUpperCase() + titleText.slice(1); // APA typically sentence case for article titles.
+    const journal = journalInfo?.title ? `<em>${journalInfo.title}</em>` : "N/A";
+    const volume = journalInfo?.volume ? `<em>${journalInfo.volume}</em>` : "";
+    const issue = journalInfo?.issue ? `(${journalInfo.issue})` : "";
+    const pages = journalInfo?.pages || "";
+    const doiLink = doi ? ` https://doi.org/${doi}` : "";
+    let apaString = `${authorsString}. (${year}). ${apaTitle}. ${journal}`;
+    if (volume)
+        apaString += `, ${volume}`;
+    if (issue)
+        apaString += issue;
+    if (pages)
+        apaString += `, ${pages}`;
+    apaString += `.${doiLink}`;
+    return apaString;
+}
+function formatAsMLA(article, context) {
+    const medlineCitation = article.MedlineCitation;
+    const articleDetails = medlineCitation?.Article;
+    const pmid = extractPmid(medlineCitation);
+    logger.debug("Formatting MLA for article", requestContextService.createRequestContext({ ...context, pmid }));
+    if (!articleDetails)
+        return "Article details not found.";
+    const parsedAuthors = extractAuthors(articleDetails.AuthorList);
+    const journalInfo = extractJournalInfo(articleDetails.Journal, medlineCitation);
+    const titleText = getText(articleDetails.ArticleTitle);
+    const doi = extractDoi(articleDetails);
+    let authorsString = "N/A";
+    if (parsedAuthors.length > 0) {
+        if (parsedAuthors.length <= 2) {
+            authorsString = parsedAuthors
+                .map((author, index) => {
+                if (author.lastName && author.firstName) {
+                    return index === 0
+                        ? `${author.lastName}, ${author.firstName}`
+                        : `${author.firstName} ${author.lastName}`;
+                }
+                if (author.lastName)
+                    return author.lastName;
+                return "";
+            })
+                .filter(Boolean)
+                .join(" and ");
+        }
+        else {
+            const firstAuthor = parsedAuthors[0];
+            if (firstAuthor.lastName && firstAuthor.firstName) {
+                authorsString = `${firstAuthor.lastName}, ${firstAuthor.firstName}, et al`;
+            }
+            else if (firstAuthor.lastName) {
+                authorsString = `${firstAuthor.lastName}, et al`;
+            }
+        }
+    }
+    const title = titleText ? `"${titleText}."` : "N/A.";
+    const journal = journalInfo?.title ? `<em>${journalInfo.title}</em>` : "N/A";
+    let publicationDateString = journalInfo?.publicationDate?.year || "";
+    if (journalInfo?.publicationDate?.month && journalInfo.publicationDate.year) {
+        const month = journalInfo.publicationDate.month.substring(0, 3) + "."; // Abbreviate month
+        publicationDateString = `${month} ${journalInfo.publicationDate.year}`;
+        if (journalInfo.publicationDate.day) {
+            publicationDateString = `${journalInfo.publicationDate.day} ${month} ${journalInfo.publicationDate.year}`;
+        }
+    }
+    else if (journalInfo?.publicationDate?.medlineDate) {
+        publicationDateString = journalInfo.publicationDate.medlineDate;
+    }
+    const volume = journalInfo?.volume ? `vol. ${journalInfo.volume}` : "";
+    const issue = journalInfo?.issue ? `no. ${journalInfo.issue}` : "";
+    const pages = journalInfo?.pages
+        ? `pp. ${journalInfo.pages.replace("-", "–")}`
+        : ""; // en-dash for MLA
+    const accessUrl = doi
+        ? `doi:${doi}`
+        : pmid
+            ? `https://pubmed.ncbi.nlm.nih.gov/${pmid}`
+            : "";
+    let mlaString = `${authorsString}. ${title} ${journal}`;
+    if (volume)
+        mlaString += `, ${volume}`;
+    if (issue)
+        mlaString += `, ${issue}`;
+    if (publicationDateString)
+        mlaString += `, ${publicationDateString}`;
+    if (pages)
+        mlaString += `, ${pages}`;
+    mlaString += `. PubMed Central, ${accessUrl}.`; // Assuming PubMed Central or just PubMed
+    return mlaString;
+}

package/dist/mcp-server/tools/getPubMedArticleConnections/logic/elinkHandler.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @fileoverview Handles ELink requests and enriches results with ESummary data
+ * for the getPubMedArticleConnections tool.
+ * @module src/mcp-server/tools/getPubMedArticleConnections/logic/elinkHandler
+ */
+import { RequestContext } from "../../../../utils/index.js";
+import type { GetPubMedArticleConnectionsInput } from "../registration.js";
+import type { ToolOutputData } from "./types.js";
+export declare function handleELinkRelationships(input: GetPubMedArticleConnectionsInput, outputData: ToolOutputData, context: RequestContext): Promise<void>;

package/dist/mcp-server/tools/getPubMedArticleConnections/logic/elinkHandler.js

@@ -0,0 +1,208 @@
+/**
+ * @fileoverview Handles ELink requests and enriches results with ESummary data
+ * for the getPubMedArticleConnections tool.
+ * @module src/mcp-server/tools/getPubMedArticleConnections/logic/elinkHandler
+ */
+import { ncbiService } from "../../../../services/NCBI/ncbiService.js";
+import { logger } from "../../../../utils/index.js";
+import { extractBriefSummaries } from "../../../../utils/parsing/ncbi-parsing/index.js";
+import { ensureArray } from "../../../../utils/parsing/ncbi-parsing/xmlGenericHelpers.js"; // Added import
+export async function handleELinkRelationships(input, outputData, context) {
+    const eLinkParams = {
+        dbfrom: "pubmed",
+        db: "pubmed",
+        id: input.sourcePmid,
+        retmode: "xml",
+        // cmd and linkname will be set below based on relationshipType
+    };
+    switch (input.relationshipType) {
+        case "pubmed_citedin":
+            eLinkParams.cmd = "neighbor_history";
+            eLinkParams.linkname = "pubmed_pubmed_citedin";
+            break;
+        case "pubmed_references":
+            eLinkParams.cmd = "neighbor_history";
+            eLinkParams.linkname = "pubmed_pubmed_refs";
+            break;
+        case "pubmed_similar_articles":
+        default: // Default to similar articles
+            eLinkParams.cmd = "neighbor_score";
+            // No linkname is explicitly needed for neighbor_score when dbfrom and db are pubmed
+            break;
+    }
+    const tempUrl = new URL("https://dummy.ncbi.nlm.nih.gov/entrez/eutils/elink.fcgi");
+    Object.keys(eLinkParams).forEach((key) => tempUrl.searchParams.append(key, String(eLinkParams[key])));
+    outputData.eUtilityUrl = `https://eutils.ncbi.nlm.nih.gov/entrez/eutils/elink.fcgi?${tempUrl.search.substring(1)}`;
+    const eLinkResult = await ncbiService.eLink(eLinkParams, context);
+    // Log the full eLinkResult for debugging
+    logger.debug("Raw eLinkResult from ncbiService:", {
+        ...context,
+        eLinkResultString: JSON.stringify(eLinkResult, null, 2),
+    });
+    // Use ensureArray for robust handling of potentially single or array eLinkResult
+    const eLinkResultsArray = ensureArray(eLinkResult?.eLinkResult);
+    const firstELinkResult = eLinkResultsArray[0]; // Get the first (or only) eLinkResult object
+    // Use ensureArray for LinkSet as well
+    const linkSetsArray = ensureArray(firstELinkResult?.LinkSet);
+    const linkSet = linkSetsArray[0]; // Get the first (or only) LinkSet object
+    let foundPmids = [];
+    if (firstELinkResult?.ERROR) {
+        const errorMsg = typeof firstELinkResult.ERROR === "string"
+            ? firstELinkResult.ERROR
+            : JSON.stringify(firstELinkResult.ERROR);
+        logger.warning(`ELink returned an error: ${errorMsg}`, context);
+        outputData.message = `ELink error: ${errorMsg}`;
+        outputData.retrievedCount = 0;
+        return;
+    }
+    if (linkSet?.LinkSetDbHistory) {
+        // Handle cmd=neighbor_history response (citedin, references)
+        const history = Array.isArray(linkSet.LinkSetDbHistory)
+            ? linkSet.LinkSetDbHistory[0]
+            : linkSet.LinkSetDbHistory;
+        if (history?.QueryKey && linkSet.WebEnv) {
+            const eSearchParams = {
+                db: "pubmed",
+                query_key: history.QueryKey,
+                WebEnv: linkSet.WebEnv,
+                retmode: "xml",
+                retmax: input.maxRelatedResults * 2, // Fetch a bit more to allow filtering sourcePmid
+            };
+            const eSearchResult = await ncbiService.eSearch(eSearchParams, context);
+            if (eSearchResult?.eSearchResult?.IdList?.Id) {
+                const ids = ensureArray(eSearchResult.eSearchResult.IdList.Id);
+                foundPmids = ids
+                    .map((idNode) => {
+                    // Allow number for idNode
+                    let pmidVal;
+                    if (typeof idNode === "object" && idNode !== null) {
+                        pmidVal = idNode["#text"];
+                    }
+                    else {
+                        pmidVal = idNode;
+                    }
+                    return {
+                        pmid: pmidVal !== undefined ? String(pmidVal) : "",
+                        // No scores from this ESearch path
+                    };
+                })
+                    .filter((item) => item.pmid && item.pmid !== input.sourcePmid && item.pmid !== "0");
+            }
+        }
+    }
+    else if (linkSet?.LinkSetDb) {
+        // Handle cmd=neighbor_score response (similar_articles)
+        const linkSetDbArray = Array.isArray(linkSet.LinkSetDb)
+            ? linkSet.LinkSetDb
+            : [linkSet.LinkSetDb];
+        const targetLinkSetDbEntry = linkSetDbArray.find((db) => db.LinkName === "pubmed_pubmed");
+        if (targetLinkSetDbEntry?.Link) {
+            const links = ensureArray(targetLinkSetDbEntry.Link); // Use ensureArray here too
+            foundPmids = links
+                .map((link) => {
+                let pmidValue;
+                if (typeof link.Id === "object" && link.Id !== null) {
+                    pmidValue = link.Id["#text"];
+                }
+                else if (link.Id !== undefined) {
+                    pmidValue = link.Id;
+                }
+                let scoreValue;
+                if (typeof link.Score === "object" && link.Score !== null) {
+                    scoreValue = link.Score["#text"];
+                }
+                else if (link.Score !== undefined) {
+                    scoreValue = link.Score;
+                }
+                const pmidString = pmidValue !== undefined ? String(pmidValue) : "";
+                return {
+                    pmid: pmidString,
+                    score: scoreValue !== undefined ? Number(scoreValue) : undefined,
+                };
+            })
+                .filter((item) => item.pmid && item.pmid !== input.sourcePmid && item.pmid !== "0");
+        }
+    }
+    if (foundPmids.length === 0) {
+        logger.warning("No related PMIDs found after ELink/ESearch processing.", context);
+        outputData.message = "No related articles found or ELink error."; // Generic message if no PMIDs
+        outputData.retrievedCount = 0;
+        return;
+    }
+    logger.debug("Found PMIDs after initial parsing and filtering (before sort):", {
+        ...context,
+        foundPmidsCount: foundPmids.length,
+        firstFewFoundPmids: foundPmids.slice(0, 3),
+    });
+    if (foundPmids.every((p) => p.score !== undefined)) {
+        foundPmids.sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+    }
+    logger.debug("Found PMIDs after sorting:", {
+        ...context,
+        sortedFoundPmidsCount: foundPmids.length,
+        firstFewSortedFoundPmids: foundPmids.slice(0, 3),
+    });
+    const pmidsToEnrich = foundPmids
+        .slice(0, input.maxRelatedResults)
+        .map((p) => p.pmid);
+    logger.debug("PMIDs to enrich with ESummary:", {
+        ...context,
+        pmidsToEnrichCount: pmidsToEnrich.length,
+        pmidsToEnrichList: pmidsToEnrich,
+    });
+    if (pmidsToEnrich.length > 0) {
+        try {
+            const summaryParams = {
+                db: "pubmed",
+                id: pmidsToEnrich.join(","),
+                version: "2.0",
+                retmode: "xml",
+            };
+            const summaryResultContainer = await ncbiService.eSummary(summaryParams, context);
+            const summaryResult = summaryResultContainer?.eSummaryResult ||
+                summaryResultContainer?.result ||
+                summaryResultContainer;
+            if (summaryResult) {
+                const briefSummaries = await extractBriefSummaries(summaryResult, context);
+                const pmidDetailsMap = new Map();
+                briefSummaries.forEach((bs) => pmidDetailsMap.set(bs.pmid, bs));
+                outputData.relatedArticles = foundPmids
+                    .filter((p) => pmidsToEnrich.includes(p.pmid))
+                    .map((p) => {
+                    const details = pmidDetailsMap.get(p.pmid);
+                    return {
+                        pmid: p.pmid,
+                        title: details?.title,
+                        authors: details?.authors,
+                        score: p.score,
+                        linkUrl: `https://pubmed.ncbi.nlm.nih.gov/${p.pmid}/`,
+                    };
+                })
+                    .slice(0, input.maxRelatedResults);
+            }
+            else {
+                logger.warning("ESummary did not return usable data for enrichment.", context);
+                outputData.relatedArticles = foundPmids
+                    .slice(0, input.maxRelatedResults)
+                    .map((p) => ({
+                    pmid: p.pmid,
+                    score: p.score,
+                    linkUrl: `https://pubmed.ncbi.nlm.nih.gov/${p.pmid}/`,
+                }));
+            }
+        }
+        catch (summaryError) {
+            logger.error("Failed to enrich related articles with summaries", summaryError instanceof Error
+                ? summaryError
+                : new Error(String(summaryError)), context);
+            outputData.relatedArticles = foundPmids
+                .slice(0, input.maxRelatedResults)
+                .map((p) => ({
+                pmid: p.pmid,
+                score: p.score,
+                linkUrl: `https://pubmed.ncbi.nlm.nih.gov/${p.pmid}/`,
+            }));
+        }
+    }
+    outputData.retrievedCount = outputData.relatedArticles.length;
+}

package/dist/mcp-server/tools/getPubMedArticleConnections/logic/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @fileoverview Main logic handler for the 'get_pubmed_article_connections' MCP tool.
+ * Orchestrates calls to ELink or citation formatting handlers.
+ * @module src/mcp-server/tools/getPubMedArticleConnections/logic/index
+ */
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { RequestContext } from "../../../../utils/index.js";
+import type { GetPubMedArticleConnectionsInput } from "../registration.js";
+/**
+ * Main handler for the 'get_pubmed_article_connections' tool.
+ * @param {GetPubMedArticleConnectionsInput} input - Validated input parameters.
+ * @param {RequestContext} context - The request context for this tool invocation.
+ * @returns {Promise<CallToolResult>} The result of the tool call.
+ */
+export declare function handleGetPubMedArticleConnections(input: GetPubMedArticleConnectionsInput, context: RequestContext): Promise<CallToolResult>;

package/dist/mcp-server/tools/getPubMedArticleConnections/logic/index.js

@@ -0,0 +1,82 @@
+/**
+ * @fileoverview Main logic handler for the 'get_pubmed_article_connections' MCP tool.
+ * Orchestrates calls to ELink or citation formatting handlers.
+ * @module src/mcp-server/tools/getPubMedArticleConnections/logic/index
+ */
+import { BaseErrorCode, McpError } from "../../../../types-global/errors.js";
+import { logger, requestContextService, sanitizeInputForLogging, } from "../../../../utils/index.js";
+import { handleCitationFormats } from "./citationFormatter.js";
+import { handleELinkRelationships } from "./elinkHandler.js";
+/**
+ * Main handler for the 'get_pubmed_article_connections' tool.
+ * @param {GetPubMedArticleConnectionsInput} input - Validated input parameters.
+ * @param {RequestContext} context - The request context for this tool invocation.
+ * @returns {Promise<CallToolResult>} The result of the tool call.
+ */
+export async function handleGetPubMedArticleConnections(input, context) {
+    const toolLogicContext = requestContextService.createRequestContext({
+        parentRequestId: context.requestId, // Link to parent context
+        operation: "handleGetPubMedArticleConnections",
+        toolName: "get_pubmed_article_connections",
+        input: sanitizeInputForLogging(input),
+    });
+    logger.info("Executing get_pubmed_article_connections tool", toolLogicContext);
+    const outputData = {
+        sourcePmid: input.sourcePmid,
+        relationshipType: input.relationshipType,
+        relatedArticles: [],
+        citations: {},
+        retrievedCount: 0,
+        eUtilityUrl: undefined, // Initialize
+        message: undefined, // Initialize
+    };
+    try {
+        switch (input.relationshipType) {
+            case "pubmed_similar_articles":
+            case "pubmed_citedin":
+            case "pubmed_references":
+                await handleELinkRelationships(input, outputData, toolLogicContext);
+                break;
+            case "citation_formats":
+                await handleCitationFormats(input, outputData, toolLogicContext);
+                break;
+            default:
+                // This case should ideally be caught by Zod schema validation beforehand
+                throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Unsupported relationshipType: ${input.relationshipType}`, { receivedType: input.relationshipType });
+        }
+        // Ensure message is set if no specific error but also no results from handlers
+        if (outputData.retrievedCount === 0 &&
+            !outputData.message &&
+            (input.relationshipType !== "citation_formats" ||
+                Object.keys(outputData.citations).length === 0)) {
+            outputData.message = "No results found for the given parameters.";
+        }
+    }
+    catch (error) {
+        logger.error("Error in getPubMedArticleConnections main logic", error, toolLogicContext);
+        outputData.message =
+            error instanceof McpError
+                ? error.message
+                : "An unexpected error occurred while processing the request.";
+        // Ensure critical details from McpError are passed through if available
+        const errorDetails = error instanceof McpError
+            ? error.details
+            : { originalError: error.message };
+        const errorPayload = {
+            ...outputData,
+            error: {
+                code: error.code || BaseErrorCode.INTERNAL_ERROR,
+                message: outputData.message,
+                details: errorDetails,
+            },
+        };
+        const content = [
+            { type: "text", text: JSON.stringify(errorPayload) },
+        ];
+        return { content, isError: true };
+    }
+    const responseContent = [
+        { type: "text", text: JSON.stringify(outputData) },
+    ];
+    return { content: responseContent, isError: false };
+}

package/dist/mcp-server/tools/getPubMedArticleConnections/logic/types.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @fileoverview Shared type definitions for the getPubMedArticleConnections tool logic.
+ * @module src/mcp-server/tools/getPubMedArticleConnections/logic/types
+ */
+import type { GetPubMedArticleConnectionsInput } from "../registration.js";
+export interface RelatedArticle {
+    pmid: string;
+    title?: string;
+    authors?: string;
+    score?: number;
+    linkUrl: string;
+}
+export interface CitationOutput {
+    ris?: string;
+    bibtex?: string;
+    apa_string?: string;
+    mla_string?: string;
+}
+export interface ToolOutputData {
+    sourcePmid: string;
+    relationshipType: GetPubMedArticleConnectionsInput["relationshipType"];
+    relatedArticles: RelatedArticle[];
+    citations: CitationOutput;
+    retrievedCount: number;
+    eUtilityUrl?: string;
+    message?: string;
+}

package/dist/mcp-server/tools/getPubMedArticleConnections/logic/types.js

@@ -0,0 +1,5 @@
+/**
+ * @fileoverview Shared type definitions for the getPubMedArticleConnections tool logic.
+ * @module src/mcp-server/tools/getPubMedArticleConnections/logic/types
+ */
+export {};

package/dist/mcp-server/tools/getPubMedArticleConnections/logic.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview Core logic for the 'get_pubmed_article_connections' MCP tool.
+ * This file now re-exports the main handler from the './logic/index.js' module.
+ * @module src/mcp-server/tools/getPubMedArticleConnections/logic
+ */
+export { handleGetPubMedArticleConnections } from "./logic/index.js";

package/dist/mcp-server/tools/getPubMedArticleConnections/logic.js

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview Core logic for the 'get_pubmed_article_connections' MCP tool.
+ * This file now re-exports the main handler from the './logic/index.js' module.
+ * @module src/mcp-server/tools/getPubMedArticleConnections/logic
+ */
+export { handleGetPubMedArticleConnections } from "./logic/index.js";