@cyanheads/pubmed-mcp-server 2.0.1 → 2.1.0

package/dist/index.js

@@ -135501,7 +135501,7 @@ config(en_default());
 // package.json
 var package_default = {
   name: "@cyanheads/pubmed-mcp-server",
-  version: "2.0.1",
+  version: "2.1.0",
   mcpName: "io.github.cyanheads/pubmed-mcp-server",
   description: "MCP server for PubMed/NCBI E-utilities integration. Search articles, fetch metadata, generate citations, explore MeSH terms, and discover related research.",
   main: "dist/index.js",
@@ -139088,7 +139088,16 @@ var NCBI_ARRAY_JPATHS = new Set([
   "DescriptorRecordSet.DescriptorRecord",
   "ConceptList.Concept",
   "TermList.Term",
-  "TreeNumberList.TreeNumber"
+  "TreeNumberList.TreeNumber",
+  "pmc-articleset.article",
+  "article-meta.article-id",
+  "article-meta.pub-date",
+  "contrib-group.contrib",
+  "kwd-group.kwd",
+  "body.sec",
+  "sec.sec",
+  "sec.p",
+  "ref-list.ref"
 ]);
 var ERROR_PATHS = [
   "eLinkResult.ERROR",
@@ -150769,809 +150778,1310 @@ class TaskManager {
   }
 }
 
-// src/services/ncbi/formatting/citation-formatter.ts
-function getYear(article) {
-  return article.journalInfo?.publicationDate?.year ?? "n.d.";
-}
-function splitPages(pages) {
-  if (!pages)
-    return {};
-  const parts = pages.split(/[-\u2013\u2014]/).map((p) => p.trim());
-  if (parts.length >= 2) {
-    const start2 = parts[0];
-    const end = parts[1];
-    return {
-      ...start2 !== undefined && { start: start2 },
-      ...end !== undefined && { end }
-    };
-  }
-  const start = parts[0];
-  return start !== undefined ? { start } : {};
-}
-function escapeBibtex(text) {
-  return text.replace(/\\/g, "\\textbackslash{}").replace(/&/g, "\\&").replace(/%/g, "\\%").replace(/\$/g, "\\$").replace(/#/g, "\\#").replace(/_/g, "\\_").replace(/\{/g, "\\{").replace(/\}/g, "\\}").replace(/~/g, "\\textasciitilde{}").replace(/\^/g, "\\textasciicircum{}");
-}
-function formatAuthorApa(author) {
-  if (author.collectiveName)
-    return author.collectiveName;
-  const last = author.lastName ?? "";
-  const initials = author.initials ?? author.firstName?.split(/[\s-]+/).map((part) => `${part[0]}.`).join(" ");
-  if (!last)
-    return initials ?? "";
-  if (!initials)
-    return last;
-  const formatted = initials.replace(/[^A-Za-z]/g, "").split("").map((c) => `${c}.`).join(" ");
-  return `${last}, ${formatted}`;
-}
-function formatAuthorsApa(authors) {
-  const formatted = authors.map(formatAuthorApa);
-  if (formatted.length === 0)
+// src/services/ncbi/parsing/pmc-article-parser.ts
+function extractTextContent(node) {
+  if (node === undefined || node === null)
     return "";
-  if (formatted.length === 1)
-    return formatted[0] ?? "";
-  if (formatted.length === 2)
-    return `${formatted[0]}, & ${formatted[1]}`;
-  if (formatted.length <= 20) {
-    const allButLast = formatted.slice(0, -1).join(", ");
-    return `${allButLast}, & ${formatted.at(-1)}`;
+  if (typeof node === "string")
+    return node;
+  if (typeof node === "number" || typeof node === "boolean")
+    return String(node);
+  if (Array.isArray(node)) {
+    return node.map(extractTextContent).filter(Boolean).join(" ");
   }
-  const first19 = formatted.slice(0, 19).join(", ");
-  return `${first19}, ... ${formatted.at(-1)}`;
-}
-function formatAuthorMla(author, isFirst) {
-  if (author.collectiveName)
-    return author.collectiveName;
-  const last = author.lastName ?? "";
-  const first = author.firstName ?? "";
-  if (!last && !first)
-    return "";
-  if (!first)
-    return last;
-  if (!last)
-    return first;
-  return isFirst ? `${last}, ${first}` : `${first} ${last}`;
-}
-function formatAuthorsMla(authors) {
-  const first = authors[0];
-  if (!first)
-    return "";
-  if (authors.length === 1)
-    return formatAuthorMla(first, true);
-  if (authors.length === 2) {
-    const second = authors[1];
-    return second ? `${formatAuthorMla(first, true)}, and ${formatAuthorMla(second, false)}` : formatAuthorMla(first, true);
+  if (typeof node === "object") {
+    const obj = node;
+    const parts = [];
+    if (obj["#text"] !== undefined) {
+      const text = typeof obj["#text"] === "string" ? obj["#text"] : String(obj["#text"]);
+      if (text)
+        parts.push(text);
+    }
+    for (const key of Object.keys(obj)) {
+      if (key === "#text" || key.startsWith("@_"))
+        continue;
+      const childText = extractTextContent(obj[key]);
+      if (childText)
+        parts.push(childText);
+    }
+    return parts.join(" ").replace(/\s+/g, " ").trim();
   }
-  return `${formatAuthorMla(first, true)}, et al.`;
-}
-function formatAuthorBibtex(author) {
-  if (author.collectiveName)
-    return `{${escapeBibtex(author.collectiveName)}}`;
-  const last = author.lastName ? escapeBibtex(author.lastName) : "";
-  const first = author.firstName ? escapeBibtex(author.firstName) : "";
-  if (!last && !first)
-    return "";
-  if (!first)
-    return `{${last}}`;
-  if (!last)
-    return first;
-  return `{${last}}, ${first}`;
+  return "";
 }
-function formatApa(article) {
-  const parts = [];
-  const authorStr = article.authors?.length ? formatAuthorsApa(article.authors) : "";
-  if (authorStr) {
-    parts.push(authorStr);
-  }
-  const year = getYear(article);
-  parts.push(`(${year}).`);
-  if (article.title) {
-    const title = article.title.replace(/\.\s*$/, "");
-    parts.push(`${title}.`);
+function extractArticleId(articleIds, pubIdType) {
+  for (const id of ensureArray(articleIds)) {
+    if (getAttribute(id, "pub-id-type") === pubIdType) {
+      const val = id["#text"];
+      if (val !== undefined)
+        return String(val);
+    }
   }
-  const journal = article.journalInfo;
-  if (journal?.title) {
-    let journalPart = `*${journal.title}*`;
-    if (journal.volume) {
-      journalPart += `, *${journal.volume}*`;
-      if (journal.issue) {
-        journalPart += `(${journal.issue})`;
+  return;
+}
+function extractJatsAuthors(contribGroups) {
+  if (!contribGroups)
+    return [];
+  const authors = [];
+  for (const group of ensureArray(contribGroups)) {
+    for (const contrib of ensureArray(group.contrib)) {
+      if (contrib["@_contrib-type"] && contrib["@_contrib-type"] !== "author")
+        continue;
+      const collectiveName = extractTextContent(contrib.collab);
+      if (collectiveName) {
+        authors.push({ collectiveName });
+        continue;
+      }
+      if (contrib.name) {
+        const lastName = extractTextContent(contrib.name.surname) || undefined;
+        const givenNames = extractTextContent(contrib.name["given-names"]) || undefined;
+        authors.push({
+          ...lastName && { lastName },
+          ...givenNames && { givenNames }
+        });
       }
     }
-    if (journal.pages) {
-      journalPart += `, ${journal.pages}`;
-    }
-    journalPart += ".";
-    parts.push(journalPart);
-  }
-  if (article.doi) {
-    parts.push(`https://doi.org/${article.doi}`);
   }
-  return parts.join(" ");
+  return authors;
 }
-function formatMla(article) {
-  const parts = [];
-  const authorStr = article.authors?.length ? formatAuthorsMla(article.authors) : "";
-  if (authorStr) {
-    parts.push(authorStr.endsWith(".") ? authorStr : `${authorStr}.`);
-  }
-  if (article.title) {
-    const title = article.title.replace(/\.\s*$/, "");
-    parts.push(`"${title}."`);
+function extractAffiliations(affs) {
+  if (!affs)
+    return [];
+  const result = [];
+  for (const aff of ensureArray(affs)) {
+    const text = extractTextContent(aff);
+    if (text)
+      result.push(text);
   }
-  const journal = article.journalInfo;
-  if (journal?.title) {
-    const detailParts = [];
-    detailParts.push(`*${journal.title}*`);
-    if (journal.volume) {
-      detailParts.push(`vol. ${journal.volume}`);
-    }
-    if (journal.issue) {
-      detailParts.push(`no. ${journal.issue}`);
+  return result;
+}
+function extractJournal(journalMeta, articleMeta) {
+  if (!journalMeta)
+    return;
+  const title = extractTextContent(journalMeta["journal-title-group"]?.["journal-title"]) || extractTextContent(journalMeta["journal-title"]) || undefined;
+  const issns = ensureArray(journalMeta.issn);
+  const issn = issns.length > 0 ? getText(issns[0]) || undefined : undefined;
+  const volume = articleMeta?.volume ? extractTextContent(articleMeta.volume) || undefined : undefined;
+  const issue2 = articleMeta?.issue ? extractTextContent(articleMeta.issue) || undefined : undefined;
+  const fpage = articleMeta?.fpage ? extractTextContent(articleMeta.fpage) : undefined;
+  const lpage = articleMeta?.lpage ? extractTextContent(articleMeta.lpage) : undefined;
+  const pages = fpage && lpage ? `${fpage}-${lpage}` : fpage || undefined;
+  if (!title && !issn && !volume && !issue2 && !pages)
+    return;
+  return {
+    ...title && { title },
+    ...issn && { issn },
+    ...volume && { volume },
+    ...issue2 && { issue: issue2 },
+    ...pages && { pages }
+  };
+}
+function extractPubDate(pubDates) {
+  if (!pubDates)
+    return;
+  const dates = ensureArray(pubDates);
+  const preferred = dates.find((d) => getAttribute(d, "pub-type") === "epub") ?? dates.find((d) => getAttribute(d, "pub-type") === "ppub") ?? dates.find((d) => getAttribute(d, "date-type") === "pub") ?? dates[0];
+  if (!preferred)
+    return;
+  const year = extractTextContent(preferred.year) || undefined;
+  const month = extractTextContent(preferred.month) || undefined;
+  const day = extractTextContent(preferred.day) || undefined;
+  if (!year)
+    return;
+  return {
+    year,
+    ...month && { month },
+    ...day && { day }
+  };
+}
+function extractAbstract(abstractNode) {
+  if (!abstractNode)
+    return;
+  if (typeof abstractNode === "object" && !Array.isArray(abstractNode)) {
+    const obj = abstractNode;
+    if (obj.sec) {
+      const sections = ensureArray(obj.sec);
+      const parts = [];
+      for (const sec of sections) {
+        const secObj = sec;
+        const title = extractTextContent(secObj.title);
+        const text2 = extractTextContent(secObj.p);
+        if (title && text2) {
+          parts.push(`${title}: ${text2}`);
+        } else if (text2) {
+          parts.push(text2);
+        }
+      }
+      const result = parts.join(`
+
+`).trim();
+      return result || undefined;
     }
-    const year = getYear(article);
-    if (year !== "n.d.") {
-      detailParts.push(year);
+    if (obj.p) {
+      const text2 = extractTextContent(obj.p);
+      return text2 || undefined;
     }
-    if (journal.pages) {
-      detailParts.push(`pp. ${journal.pages}`);
+  }
+  const text = extractTextContent(abstractNode);
+  return text || undefined;
+}
+function extractKeywords(kwdGroups) {
+  if (!kwdGroups)
+    return [];
+  const keywords = [];
+  for (const group of ensureArray(kwdGroups)) {
+    for (const kwd of ensureArray(group.kwd)) {
+      const text = extractTextContent(kwd);
+      if (text)
+        keywords.push(text);
     }
-    parts.push(`${detailParts.join(", ")}.`);
   }
-  if (article.doi) {
-    parts.push(`https://doi.org/${article.doi}.`);
+  return keywords;
+}
+function extractBodySections(body) {
+  if (!body)
+    return [];
+  if (!body.sec) {
+    if (body.p) {
+      const text = extractTextContent(body.p);
+      return text ? [{ text }] : [];
+    }
+    return [];
   }
-  return parts.join(" ");
+  return ensureArray(body.sec).map(extractSection).filter((s) => s !== null);
 }
-function formatBibtex(article) {
-  const key = `pmid${article.pmid}`;
-  const fields = [];
-  if (article.authors?.length) {
-    const authorStr = article.authors.map(formatAuthorBibtex).filter(Boolean).join(" and ");
-    if (authorStr)
-      fields.push(["author", authorStr]);
+function extractSection(sec) {
+  const title = extractTextContent(sec.title) || undefined;
+  const label = extractTextContent(sec.label) || undefined;
+  const paragraphs = ensureArray(sec.p);
+  const textParts = [];
+  for (const p of paragraphs) {
+    const text2 = extractTextContent(p);
+    if (text2)
+      textParts.push(text2);
   }
-  if (article.title) {
-    fields.push(["title", `{${escapeBibtex(article.title)}}`]);
+  const subsections = sec.sec ? ensureArray(sec.sec).map(extractSection).filter((s) => s !== null) : undefined;
+  const text = textParts.join(`
+
+`);
+  if (!text && (!subsections || subsections.length === 0))
+    return null;
+  return {
+    ...title && { title },
+    ...label && { label },
+    text,
+    ...subsections && subsections.length > 0 && { subsections }
+  };
+}
+function extractReferences(back) {
+  if (!back?.["ref-list"]?.ref)
+    return [];
+  const refs = ensureArray(back["ref-list"].ref);
+  const results = [];
+  for (const ref of refs) {
+    const citationNode = ref["mixed-citation"] ?? ref["element-citation"];
+    const citation = extractTextContent(citationNode);
+    if (!citation)
+      continue;
+    const label = ref.label ? extractTextContent(ref.label) || undefined : undefined;
+    results.push({
+      ...ref["@_id"] && { id: ref["@_id"] },
+      ...label && { label },
+      citation
+    });
+  }
+  return results;
+}
+function parsePmcArticle(xmlArticle) {
+  const front = xmlArticle.front;
+  const articleMeta = front?.["article-meta"];
+  const journalMeta = front?.["journal-meta"];
+  const articleIds = articleMeta?.["article-id"];
+  const pmcId = extractArticleId(articleIds, "pmcid") ?? extractArticleId(articleIds, "pmc-uid") ?? "";
+  const pmid = extractArticleId(articleIds, "pmid");
+  const doi = extractArticleId(articleIds, "doi");
+  const title = articleMeta?.["title-group"] ? extractTextContent(articleMeta["title-group"]["article-title"]) || undefined : undefined;
+  const authors = extractJatsAuthors(articleMeta?.["contrib-group"]);
+  const affiliations = extractAffiliations(articleMeta?.aff);
+  const journal = extractJournal(journalMeta, articleMeta);
+  const publicationDate = extractPubDate(articleMeta?.["pub-date"]);
+  const abstract = extractAbstract(articleMeta?.abstract);
+  const keywords = extractKeywords(articleMeta?.["kwd-group"]);
+  const sections = extractBodySections(xmlArticle.body);
+  const references = extractReferences(xmlArticle.back);
+  const normalizedPmcId = pmcId.startsWith("PMC") ? pmcId : `PMC${pmcId}`;
+  return {
+    pmcId: normalizedPmcId,
+    ...pmid && { pmid },
+    ...doi && { doi },
+    ...title && { title },
+    ...authors.length > 0 && { authors },
+    ...affiliations.length > 0 && { affiliations },
+    ...journal && { journal },
+    ...publicationDate && { publicationDate },
+    ...abstract && { abstract },
+    ...keywords.length > 0 && { keywords },
+    sections,
+    ...references.length > 0 && { references },
+    ...xmlArticle["@_article-type"] && { articleType: xmlArticle["@_article-type"] },
+    pmcUrl: `https://www.ncbi.nlm.nih.gov/pmc/articles/${normalizedPmcId}/`,
+    ...pmid && { pubmedUrl: `https://pubmed.ncbi.nlm.nih.gov/${pmid}/` }
+  };
+}
+
+// src/utils/formatting/markdownBuilder.ts
+class MarkdownBuilder {
+  sections = [];
+  h1(text, emoji3) {
+    const prefix = emoji3 ? `${emoji3} ` : "";
+    this.sections.push(`# ${prefix}${text}
+
+`);
+    return this;
   }
-  const journal = article.journalInfo;
-  if (journal?.title) {
-    fields.push(["journal", escapeBibtex(journal.title)]);
+  h2(text, emoji3) {
+    const prefix = emoji3 ? `${emoji3} ` : "";
+    this.sections.push(`## ${prefix}${text}
+
+`);
+    return this;
   }
-  const year = getYear(article);
-  if (year !== "n.d.") {
-    fields.push(["year", year]);
+  h3(text, emoji3) {
+    const prefix = emoji3 ? `${emoji3} ` : "";
+    this.sections.push(`### ${prefix}${text}
+
+`);
+    return this;
   }
-  if (journal?.volume) {
-    fields.push(["volume", escapeBibtex(journal.volume)]);
+  h4(text, emoji3) {
+    const prefix = emoji3 ? `${emoji3} ` : "";
+    this.sections.push(`#### ${prefix}${text}
+
+`);
+    return this;
   }
-  if (journal?.issue) {
-    fields.push(["number", escapeBibtex(journal.issue)]);
+  keyValue(key, value) {
+    const displayValue = value === null ? "null" : String(value);
+    this.sections.push(`**${key}:** ${displayValue}
+`);
+    return this;
   }
-  if (journal?.pages) {
-    fields.push(["pages", escapeBibtex(journal.pages)]);
+  keyValuePlain(key, value) {
+    const displayValue = value === null ? "null" : String(value);
+    this.sections.push(`${key}: ${displayValue}
+`);
+    return this;
   }
-  if (article.doi) {
-    fields.push(["doi", article.doi]);
+  list(items, ordered = false) {
+    if (items.length === 0)
+      return this;
+    const marker = ordered ? (i) => `${i + 1}.` : () => "-";
+    this.sections.push(`${items.map((item, i) => `${marker(i)} ${item}`).join(`
+`)}
+
+`);
+    return this;
   }
-  fields.push(["pmid", article.pmid]);
-  const maxKeyLen = Math.max(...fields.map(([k]) => k.length));
-  const fieldLines = fields.map(([k, v]) => `  ${k.padEnd(maxKeyLen)} = {${v}}`).join(`,
+  codeBlock(content, language = "") {
+    this.sections.push(`\`\`\`${language}
+${content}
+\`\`\`
+
 `);
-  return `@article{${key},
-${fieldLines}
-}`;
-}
-function formatRis(article) {
-  const lines = [];
-  const tag = (code, value) => {
-    if (value)
-      lines.push(`${code}  - ${value}`);
-  };
-  lines.push("TY  - JOUR");
-  if (article.authors?.length) {
-    for (const author of article.authors) {
-      if (author.collectiveName) {
-        tag("AU", author.collectiveName);
-      } else {
-        const last = author.lastName ?? "";
-        const first = author.firstName ?? "";
-        if (last || first) {
-          tag("AU", first ? `${last}, ${first}` : last);
-        }
-      }
-    }
+    return this;
   }
-  tag("TI", article.title);
-  const journal = article.journalInfo;
-  if (journal?.title) {
-    tag("JF", journal.title);
+  inlineCode(code) {
+    this.sections.push(`\`${code}\``);
+    return this;
   }
-  if (journal?.isoAbbreviation) {
-    tag("JO", journal.isoAbbreviation);
+  paragraph(text) {
+    this.sections.push(`${text}
+
+`);
+    return this;
   }
-  const year = getYear(article);
-  if (year !== "n.d.") {
-    tag("PY", year);
+  blockquote(text) {
+    const lines = text.split(`
+`);
+    const quoted = lines.map((line) => `> ${line}`).join(`
+`);
+    this.sections.push(`${quoted}
+
+`);
+    return this;
   }
-  tag("VL", journal?.volume);
-  tag("IS", journal?.issue);
-  if (journal?.pages) {
-    const { start, end } = splitPages(journal.pages);
-    tag("SP", start);
-    tag("EP", end);
+  hr() {
+    this.sections.push(`---
+
+`);
+    return this;
   }
-  tag("DO", article.doi);
-  tag("AN", article.pmid);
-  lines.push(`UR  - https://pubmed.ncbi.nlm.nih.gov/${article.pmid}/`);
-  if (article.keywords?.length) {
-    for (const kw of article.keywords) {
-      tag("KW", kw);
+  link(text, url2) {
+    this.sections.push(`[${text}](${url2})`);
+    return this;
+  }
+  table(headers, rows) {
+    if (headers.length === 0 || rows.length === 0)
+      return this;
+    this.sections.push(`| ${headers.join(" | ")} |
+`);
+    this.sections.push(`| ${headers.map(() => "---").join(" | ")} |
+`);
+    rows.forEach((row) => {
+      this.sections.push(`| ${row.join(" | ")} |
+`);
+    });
+    this.sections.push(`
+`);
+    return this;
+  }
+  section(title, levelOrContent, content) {
+    let level;
+    let callback;
+    if (typeof levelOrContent === "function") {
+      level = 2;
+      callback = levelOrContent;
+    } else {
+      level = levelOrContent;
+      callback = content ?? (() => {});
+    }
+    switch (level) {
+      case 2:
+        this.h2(title);
+        break;
+      case 3:
+        this.h3(title);
+        break;
+      case 4:
+        this.h4(title);
+        break;
     }
+    callback();
+    return this;
   }
-  tag("AB", article.abstractText);
-  lines.push("ER  - ");
-  return lines.join(`
+  details(summary, details) {
+    this.sections.push(`<details>
+<summary>${summary}</summary>
+
 `);
-}
-function formatCitation(article, style) {
-  switch (style) {
-    case "apa":
-      return formatApa(article);
-    case "mla":
-      return formatMla(article);
-    case "bibtex":
-      return formatBibtex(article);
-    case "ris":
-      return formatRis(article);
+    this.sections.push(`${details}
+
+`);
+    this.sections.push(`</details>
+
+`);
+    return this;
   }
-}
-function formatCitations(article, styles) {
-  const result = {};
-  for (const style of styles) {
-    result[style] = formatCitation(article, style);
+  alert(type, content) {
+    const typeUpper = type.toUpperCase();
+    const lines = content.split(`
+`);
+    this.sections.push(`> [!${typeUpper}]
+`);
+    lines.forEach((line) => {
+      this.sections.push(`> ${line}
+`);
+    });
+    this.sections.push(`
+`);
+    return this;
   }
-  return result;
-}
+  taskList(items) {
+    if (items.length === 0)
+      return this;
+    this.sections.push(`${items.map((item) => `- [${item.checked ? "x" : " "}] ${item.text}`).join(`
+`)}
 
-// src/services/ncbi/parsing/article-parser.ts
-function extractAuthors(authorListXml) {
-  if (!authorListXml)
-    return { authors: [], affiliations: [] };
-  const affiliationMap = new Map;
-  const affiliationList = [];
-  function getAffiliationIndex(text) {
-    const existing = affiliationMap.get(text);
-    if (existing !== undefined)
-      return existing;
-    const idx = affiliationList.length;
-    affiliationList.push(text);
-    affiliationMap.set(text, idx);
-    return idx;
+`);
+    return this;
   }
-  const xmlAuthors = ensureArray(authorListXml.Author);
-  const authors = xmlAuthors.map((auth) => {
-    const collectiveName = getText(auth.CollectiveName);
-    if (collectiveName) {
-      return { collectiveName };
+  image(altText, url2, title) {
+    const titlePart = title ? ` "${title}"` : "";
+    this.sections.push(`![${altText}](${url2}${titlePart})
+
+`);
+    return this;
+  }
+  strikethrough(text) {
+    this.sections.push(`~~${text}~~`);
+    return this;
+  }
+  diff(changes) {
+    const lines = [];
+    if (changes.context) {
+      lines.push(...changes.context.map((line) => `  ${line}`));
     }
-    const authorAffiliationInfos = ensureArray(auth.AffiliationInfo);
-    const indices = [];
-    for (const info of authorAffiliationInfos) {
-      const text = getText(info?.Affiliation);
-      if (text)
-        indices.push(getAffiliationIndex(text));
+    if (changes.deletions) {
+      lines.push(...changes.deletions.map((line) => `- ${line}`));
     }
-    let orcid;
-    const identifiers = ensureArray(auth.Identifier);
-    for (const id of identifiers) {
-      if (getAttribute(id, "Source") === "ORCID") {
-        const val = getText(id);
-        if (val) {
-          orcid = val;
-          break;
-        }
-      }
+    if (changes.additions) {
+      lines.push(...changes.additions.map((line) => `+ ${line}`));
     }
-    return {
-      lastName: getText(auth.LastName),
-      firstName: getText(auth.ForeName),
-      initials: getText(auth.Initials),
-      ...indices.length > 0 && { affiliationIndices: indices },
-      ...orcid && { orcid }
-    };
-  });
-  return { authors, affiliations: affiliationList };
-}
-function extractJournalInfo(journalXml, articleXml) {
-  if (!journalXml)
-    return;
-  const pubDate = journalXml.JournalIssue?.PubDate;
-  const year = getText(pubDate?.Year, getText(pubDate?.MedlineDate, "").match(/\d{4}/)?.[0]);
-  const issnElement = journalXml.ISSN;
-  const issnValue = getText(issnElement);
-  const issnType = getAttribute(issnElement, "IssnType");
-  const issn = issnType === "Electronic" ? undefined : issnValue || undefined;
-  const eIssn = issnType === "Electronic" ? issnValue || undefined : undefined;
-  return {
-    title: getText(journalXml.Title),
-    isoAbbreviation: getText(journalXml.ISOAbbreviation),
-    ...issn && { issn },
-    ...eIssn && { eIssn },
-    volume: getText(journalXml.JournalIssue?.Volume),
-    issue: getText(journalXml.JournalIssue?.Issue),
-    pages: getText(articleXml?.Pagination?.MedlinePgn),
-    publicationDate: {
-      ...year && { year },
-      ...getText(pubDate?.Month) && { month: getText(pubDate?.Month) },
-      ...getText(pubDate?.Day) && { day: getText(pubDate?.Day) },
-      ...getText(pubDate?.MedlineDate) && { medlineDate: getText(pubDate?.MedlineDate) }
+    if (lines.length > 0) {
+      this.codeBlock(lines.join(`
+`), "diff");
     }
-  };
+    return this;
+  }
+  badge(label, message, color = "blue") {
+    const encodedLabel = encodeURIComponent(label);
+    const encodedMessage = encodeURIComponent(message);
+    const url2 = `https://img.shields.io/badge/${encodedLabel}-${encodedMessage}-${color}`;
+    this.sections.push(`![${label}: ${message}](${url2})`);
+    return this;
+  }
+  bold(text) {
+    this.sections.push(`**${text}**`);
+    return this;
+  }
+  italic(text) {
+    this.sections.push(`*${text}*`);
+    return this;
+  }
+  boldItalic(text) {
+    this.sections.push(`***${text}***`);
+    return this;
+  }
+  raw(markdown) {
+    this.sections.push(markdown);
+    return this;
+  }
+  blankLine() {
+    this.sections.push(`
+`);
+    return this;
+  }
+  text(text) {
+    this.sections.push(text);
+    return this;
+  }
+  when(condition, content) {
+    if (condition) {
+      content();
+    }
+    return this;
+  }
+  build() {
+    return this.sections.join("").trim();
+  }
+  reset() {
+    this.sections = [];
+    return this;
+  }
 }
-function extractMeshTerms(meshHeadingListXml) {
-  if (!meshHeadingListXml)
-    return [];
-  const meshHeadings = ensureArray(meshHeadingListXml.MeshHeading);
-  return meshHeadings.map((mh) => {
-    const isMajorDescriptor = getAttribute(mh.DescriptorName, "MajorTopicYN") === "Y";
-    const isMajorRoot = getAttribute(mh, "MajorTopicYN") === "Y";
-    const descriptorUi = getAttribute(mh.DescriptorName, "UI");
-    const rawQualifiers = ensureArray(mh.QualifierName);
-    const qualifiers = rawQualifiers.flatMap((q) => {
-      const name = getText(q);
-      if (!name)
-        return [];
-      const ui = getAttribute(q, "UI");
-      return {
-        qualifierName: name,
-        ...ui && { qualifierUi: ui },
-        isMajorTopic: getAttribute(q, "MajorTopicYN") === "Y"
-      };
-    });
-    const isMajorAnyQualifier = qualifiers.some((q) => q.isMajorTopic);
-    return {
-      descriptorName: getText(mh.DescriptorName),
-      ...descriptorUi && { descriptorUi },
-      ...qualifiers.length > 0 && { qualifiers },
-      isMajorTopic: isMajorRoot || isMajorDescriptor || isMajorAnyQualifier
-    };
-  });
+function markdown() {
+  return new MarkdownBuilder;
 }
-function extractGrants(grantListXml) {
-  if (!grantListXml)
-    return [];
-  const grants = ensureArray(grantListXml.Grant);
-  return grants.map((g) => {
-    const grantId = getText(g.GrantID);
-    const acronym = getText(g.Acronym);
-    const agency = getText(g.Agency);
-    const country = getText(g.Country);
-    return {
-      ...grantId && { grantId },
-      ...acronym && { acronym },
-      ...agency && { agency },
-      ...country && { country }
-    };
-  });
+
+// src/mcp-server/tools/definitions/pmc-fetch.tool.ts
+var ncbi2 = () => container.resolve(NcbiServiceToken);
+var TOOL_NAME = "pmc_fetch";
+var TOOL_TITLE = "PMC Full-Text Fetch";
+var TOOL_DESCRIPTION = "Fetch full-text articles from PubMed Central (PMC). Returns complete article body text, sections, and references for open-access articles. Accepts PMC IDs directly or PubMed IDs (auto-resolved via ELink). Only articles available in PMC will return full text.";
+var TOOL_ANNOTATIONS = {
+  idempotentHint: true,
+  openWorldHint: true,
+  readOnlyHint: true
+};
+var InputSchema = exports_external.object({
+  includeReferences: exports_external.boolean().default(false).describe("Include reference list from back matter"),
+  maxSections: exports_external.number().int().min(1).max(50).optional().describe("Maximum number of top-level body sections to return"),
+  pmcids: exports_external.array(exports_external.string()).min(1).max(10).optional().describe('PMC IDs to fetch (e.g., ["PMC9575052"] or ["9575052"]). Provide pmcids or pmids, not both.'),
+  pmids: exports_external.array(exports_external.string().regex(/^\d+$/)).min(1).max(10).optional().describe("PubMed IDs to resolve to PMC articles via ELink. Only articles available in PMC will be returned."),
+  sections: exports_external.array(exports_external.string()).optional().describe('Filter to specific sections by title (case-insensitive match, e.g., ["methods", "results"])')
+}).refine((data) => data.pmcids ?? data.pmids, {
+  message: "Either pmcids or pmids must be provided"
+}).refine((data) => !(data.pmcids && data.pmids), {
+  message: "Provide pmcids or pmids, not both"
+});
+var SectionSchema = exports_external.object({
+  label: exports_external.string().optional().describe('Section label (e.g., "1", "2.1")'),
+  subsections: exports_external.lazy(() => exports_external.array(SectionSchema)).optional().describe("Nested subsections"),
+  text: exports_external.string().describe("Section body text"),
+  title: exports_external.string().optional().describe("Section heading")
+});
+var ArticleSchema = exports_external.object({
+  abstract: exports_external.string().optional().describe("Article abstract"),
+  affiliations: exports_external.array(exports_external.string()).optional().describe("Author affiliations"),
+  articleType: exports_external.string().optional().describe('Article type (e.g., "research-article")'),
+  authors: exports_external.array(exports_external.object({
+    collectiveName: exports_external.string().optional(),
+    givenNames: exports_external.string().optional(),
+    lastName: exports_external.string().optional()
+  })).optional().describe("Author list"),
+  doi: exports_external.string().optional().describe("Digital Object Identifier"),
+  journal: exports_external.any().optional().describe("Journal information"),
+  keywords: exports_external.array(exports_external.string()).optional().describe("Article keywords"),
+  pmcId: exports_external.string().describe("PubMed Central ID"),
+  pmcUrl: exports_external.string().describe("PMC article URL"),
+  pmid: exports_external.string().optional().describe("PubMed ID"),
+  pubmedUrl: exports_external.string().optional().describe("PubMed article URL"),
+  publicationDate: exports_external.any().optional().describe("Publication date"),
+  references: exports_external.array(exports_external.object({ citation: exports_external.string(), id: exports_external.string().optional(), label: exports_external.string().optional() })).optional().describe("Reference list"),
+  sections: exports_external.array(SectionSchema).describe("Article body sections with full text"),
+  title: exports_external.string().optional().describe("Article title")
+});
+var OutputSchema2 = exports_external.object({
+  articles: exports_external.array(ArticleSchema).describe("Parsed full-text articles"),
+  totalReturned: exports_external.number().describe("Number of articles returned"),
+  unavailablePmids: exports_external.array(exports_external.string()).optional().describe("PMIDs that could not be resolved to PMC articles")
+});
+function normalizePmcId(id) {
+  return id.replace(/^PMC/i, "");
 }
-function extractDoi(articleXml, pubmedDataArticleIdList) {
-  if (!articleXml)
-    return;
-  const eLocationIDs = ensureArray(articleXml.ELocationID);
-  for (const eloc of eLocationIDs) {
-    if (getAttribute(eloc, "EIdType") === "doi" && getAttribute(eloc, "ValidYN") === "Y") {
-      const doi = getText(eloc);
-      if (doi)
-        return doi;
-    }
-  }
-  for (const eloc of eLocationIDs) {
-    if (getAttribute(eloc, "EIdType") === "doi") {
-      const doi = getText(eloc);
-      if (doi)
-        return doi;
-    }
+function extractLinkId(field) {
+  if (field === undefined || field === null)
+    return "";
+  if (typeof field === "object") {
+    return field["#text"] !== undefined ? String(field["#text"]) : "";
   }
-  const articleIds = ensureArray(articleXml.ArticleIdList?.ArticleId);
-  for (const aid of articleIds) {
-    if (getAttribute(aid, "IdType") === "doi") {
-      const doi = getText(aid);
-      if (doi)
-        return doi;
+  return String(field);
+}
+async function resolvePmidsToPmcIds(pmids, appContext) {
+  const eLinkResult = await ncbi2().eLink({
+    cmd: "neighbor",
+    db: "pmc",
+    dbfrom: "pubmed",
+    id: pmids.join(","),
+    linkname: "pubmed_pmc",
+    retmode: "xml"
+  }, appContext);
+  const resolved = new Map;
+  const eLinkResults = ensureArray(eLinkResult?.eLinkResult);
+  for (const result of eLinkResults) {
+    if (result?.ERROR) {
+      logger.warning("ELink error during PMID resolution", {
+        ...appContext,
+        error: result.ERROR
+      });
+      continue;
     }
-  }
-  if (pubmedDataArticleIdList) {
-    const pubmedDataIds = ensureArray(pubmedDataArticleIdList.ArticleId);
-    for (const aid of pubmedDataIds) {
-      if (getAttribute(aid, "IdType") === "doi") {
-        const doi = getText(aid);
-        if (doi)
-          return doi;
+    const linkSet = result?.LinkSet;
+    if (!linkSet?.LinkSetDb)
+      continue;
+    const linkSetDbArray = ensureArray(linkSet.LinkSetDb);
+    const pmcLinkSet = linkSetDbArray.find((db) => db.LinkName === "pubmed_pmc") ?? linkSetDbArray[0];
+    if (pmcLinkSet?.Link) {
+      const sourcePmid = extractLinkId(linkSet.IdList?.Id);
+      const links = ensureArray(pmcLinkSet.Link);
+      for (const link of links) {
+        const pmcId = extractLinkId(link.Id);
+        if (pmcId && sourcePmid) {
+          resolved.set(sourcePmid, pmcId);
+        }
       }
     }
   }
-  return;
+  const unavailable = pmids.filter((pmid) => !resolved.has(pmid));
+  return { resolved, unavailable };
 }
-function extractPmcId(articleXml, pubmedDataArticleIdList) {
-  const articleIds = ensureArray(articleXml?.ArticleIdList?.ArticleId);
-  for (const aid of articleIds) {
-    if (getAttribute(aid, "IdType") === "pmc") {
-      const val = getText(aid);
-      if (val)
-        return val;
+function filterSections(sections, sectionFilter) {
+  const lowerFilter = sectionFilter.map((s) => s.toLowerCase());
+  return sections.filter((s) => {
+    if (!s.title)
+      return false;
+    return lowerFilter.some((f) => s.title?.toLowerCase().includes(f));
+  });
+}
+async function logic(input, appContext, _sdkContext) {
+  logger.info("Executing pmc_fetch tool", {
+    ...appContext,
+    hasPmcids: !!input.pmcids,
+    hasPmids: !!input.pmids,
+    idCount: (input.pmcids ?? input.pmids)?.length
+  });
+  let pmcIds;
+  let unavailablePmids;
+  if (input.pmids) {
+    const resolution = await resolvePmidsToPmcIds(input.pmids, appContext);
+    if (resolution.resolved.size === 0) {
+      logger.notice("No PMC articles found for provided PMIDs", {
+        ...appContext,
+        pmids: input.pmids
+      });
+      return {
+        articles: [],
+        totalReturned: 0,
+        unavailablePmids: input.pmids
+      };
     }
-  }
-  if (pubmedDataArticleIdList) {
-    const pubmedDataIds = ensureArray(pubmedDataArticleIdList.ArticleId);
-    for (const aid of pubmedDataIds) {
-      if (getAttribute(aid, "IdType") === "pmc") {
-        const val = getText(aid);
-        if (val)
-          return val;
-      }
+    pmcIds = [...resolution.resolved.values()];
+    if (resolution.unavailable.length > 0) {
+      unavailablePmids = resolution.unavailable;
+      logger.debug("Some PMIDs not available in PMC", {
+        ...appContext,
+        unavailable: resolution.unavailable
+      });
     }
+  } else {
+    pmcIds = (input.pmcids ?? []).map(normalizePmcId);
+  }
+  const xmlData = await ncbi2().eFetch({ db: "pmc", id: pmcIds.join(","), retmode: "xml" }, appContext, { retmode: "xml", usePost: pmcIds.length > 5 });
+  if (!xmlData || !("pmc-articleset" in xmlData)) {
+    throw new McpError(-32603 /* InternalError */, "Invalid PMC EFetch response: missing pmc-articleset", { requestId: appContext.requestId });
+  }
+  const articleSet = xmlData["pmc-articleset"];
+  if (!articleSet?.article) {
+    return { articles: [], totalReturned: 0, ...unavailablePmids && { unavailablePmids } };
+  }
+  const xmlArticles = ensureArray(articleSet.article);
+  let articles = xmlArticles.map((xmlArticle) => parsePmcArticle(xmlArticle));
+  if (input.sections && input.sections.length > 0) {
+    const sectionFilter = input.sections;
+    articles = articles.map((article) => ({
+      ...article,
+      sections: filterSections(article.sections, sectionFilter)
+    }));
   }
-  return;
-}
-function extractPublicationTypes(publicationTypeListXml) {
-  if (!publicationTypeListXml)
-    return [];
-  const pubTypes = ensureArray(publicationTypeListXml.PublicationType);
-  return pubTypes.map((pt) => getText(pt)).filter(Boolean);
+  if (input.maxSections !== undefined) {
+    articles = articles.map((article) => ({
+      ...article,
+      sections: article.sections.slice(0, input.maxSections)
+    }));
+  }
+  if (!input.includeReferences) {
+    articles = articles.map((article) => {
+      const { references: _refs, ...rest } = article;
+      return rest;
+    });
+  }
+  logger.notice("pmc_fetch completed", {
+    ...appContext,
+    requested: pmcIds.length,
+    returned: articles.length
+  });
+  return {
+    articles,
+    totalReturned: articles.length,
+    ...unavailablePmids && { unavailablePmids }
+  };
 }
-function extractKeywords(keywordListsXml) {
-  if (!keywordListsXml)
-    return [];
-  const lists = ensureArray(keywordListsXml);
-  const allKeywords = [];
-  for (const list of lists) {
-    for (const kw of ensureArray(list.Keyword)) {
-      const keywordText = getText(kw);
-      if (keywordText) {
-        allKeywords.push(keywordText);
-      }
+function formatSection(md, section, depth) {
+  const headingLevel = Math.min(depth, 6);
+  const prefix = "#".repeat(headingLevel);
+  if (section.title) {
+    md.text(`${prefix} ${section.title}
+
+`);
+  }
+  if (section.text) {
+    md.paragraph(section.text);
+  }
+  if (section.subsections) {
+    for (const sub of section.subsections) {
+      formatSection(md, sub, depth + 1);
     }
   }
-  return allKeywords;
 }
-function extractAbstractText(abstractXml) {
-  if (!abstractXml || !abstractXml.AbstractText)
-    return;
-  const abstractTexts = ensureArray(abstractXml.AbstractText);
-  if (abstractTexts.length === 0)
-    return;
-  const processedTexts = abstractTexts.map((at) => {
-    if (typeof at === "string") {
-      return at;
+function responseFormatter(result) {
+  const md = markdown().h2("PMC Full-Text Articles").keyValue("Articles Returned", result.totalReturned);
+  if (result.unavailablePmids?.length) {
+    md.keyValue("Unavailable PMIDs", result.unavailablePmids.join(", "));
+  }
+  for (const article of result.articles) {
+    md.h3(article.title ?? article.pmcId);
+    md.keyValue("PMCID", article.pmcId);
+    if (article.pmid)
+      md.keyValue("PMID", article.pmid);
+    if (article.doi)
+      md.keyValue("DOI", article.doi);
+    md.keyValue("PMC", article.pmcUrl);
+    if (article.pubmedUrl)
+      md.keyValue("PubMed", article.pubmedUrl);
+    if (article.authors?.length) {
+      const authorStr = article.authors.slice(0, 5).map((a) => a.collectiveName ?? `${a.lastName ?? ""} ${a.givenNames ?? ""}`.trim()).join(", ");
+      md.keyValue("Authors", article.authors.length > 5 ? `${authorStr}, et al.` : authorStr);
     }
-    const sectionText = getText(at);
-    const label = getAttribute(at, "Label");
-    if (label && sectionText) {
-      return `${label.trim()}: ${sectionText.trim()}`;
+    if (article.journal) {
+      const parts = [article.journal.title, article.journal.volume, article.journal.pages].filter(Boolean);
+      if (parts.length > 0)
+        md.keyValue("Journal", parts.join(", "));
     }
-    return sectionText.trim();
-  }).filter(Boolean);
-  if (processedTexts.length === 0)
-    return;
-  return processedTexts.join(`
+    if (article.abstract) {
+      md.h4("Abstract").paragraph(article.abstract);
+    }
+    if (article.sections.length > 0) {
+      for (const section of article.sections) {
+        formatSection(md, section, 4);
+      }
+    }
+    if (article.references?.length) {
+      md.h4("References");
+      const refItems = article.references.map((r) => `${r.label ? `[${r.label}] ` : ""}${r.citation}`);
+      md.list(refItems);
+    }
+  }
+  return [{ type: "text", text: md.build() }];
+}
+var pmcFetchTool = {
+  annotations: TOOL_ANNOTATIONS,
+  description: TOOL_DESCRIPTION,
+  inputSchema: InputSchema,
+  logic: withToolAuth(["tool:pmc_fetch:read"], logic),
+  name: TOOL_NAME,
+  outputSchema: OutputSchema2,
+  responseFormatter,
+  title: TOOL_TITLE
+};
 
-`).trim() || undefined;
+// src/services/ncbi/formatting/citation-formatter.ts
+function getYear(article) {
+  return article.journalInfo?.publicationDate?.year ?? "n.d.";
 }
-function extractPmid(medlineCitationXml) {
-  if (!medlineCitationXml || !medlineCitationXml.PMID)
-    return;
-  return getText(medlineCitationXml.PMID);
+function splitPages(pages) {
+  if (!pages)
+    return {};
+  const parts = pages.split(/[-\u2013\u2014]/).map((p) => p.trim());
+  if (parts.length >= 2) {
+    const start2 = parts[0];
+    const end = parts[1];
+    return {
+      ...start2 !== undefined && { start: start2 },
+      ...end !== undefined && { end }
+    };
+  }
+  const start = parts[0];
+  return start !== undefined ? { start } : {};
 }
-function extractArticleDates(articleXml) {
-  if (!articleXml || !articleXml.ArticleDate)
-    return [];
-  const articleDatesXml = ensureArray(articleXml.ArticleDate);
-  return articleDatesXml.map((ad) => ({
-    dateType: getAttribute(ad, "DateType"),
-    year: getText(ad.Year),
-    month: getText(ad.Month),
-    day: getText(ad.Day)
-  }));
+function escapeBibtex(text) {
+  return text.replace(/\\/g, "\\textbackslash{}").replace(/&/g, "\\&").replace(/%/g, "\\%").replace(/\$/g, "\\$").replace(/#/g, "\\#").replace(/_/g, "\\_").replace(/\{/g, "\\{").replace(/\}/g, "\\}").replace(/~/g, "\\textasciitilde{}").replace(/\^/g, "\\textasciicircum{}");
 }
-function parseFullArticle(xmlArticle, options = {}) {
-  const medlineCitation = xmlArticle.MedlineCitation;
-  const article = medlineCitation?.Article;
-  const { includeMesh = true, includeGrants = false } = options;
-  const abstractText = extractAbstractText(article?.Abstract);
-  const journalInfo = extractJournalInfo(article?.Journal, article);
-  const pubmedDataArticleIdList = xmlArticle.PubmedData?.ArticleIdList;
-  const doi = extractDoi(article, pubmedDataArticleIdList);
-  const pmcId = extractPmcId(article, pubmedDataArticleIdList);
-  const { authors, affiliations } = extractAuthors(article?.AuthorList);
-  return {
-    pmid: extractPmid(medlineCitation) ?? "",
-    title: getText(article?.ArticleTitle),
-    ...abstractText !== undefined && { abstractText },
-    ...affiliations.length > 0 && { affiliations },
-    authors,
-    ...journalInfo !== undefined && { journalInfo },
-    publicationTypes: extractPublicationTypes(article?.PublicationTypeList),
-    keywords: extractKeywords(medlineCitation?.KeywordList ?? article?.KeywordList),
-    ...includeMesh && { meshTerms: extractMeshTerms(medlineCitation?.MeshHeadingList) },
-    ...includeGrants && { grantList: extractGrants(article?.GrantList) },
-    ...doi !== undefined && { doi },
-    ...pmcId !== undefined && { pmcId },
-    articleDates: extractArticleDates(article)
-  };
+function formatAuthorApa(author) {
+  if (author.collectiveName)
+    return author.collectiveName;
+  const last = author.lastName ?? "";
+  const initials = author.initials ?? author.firstName?.split(/[\s-]+/).map((part) => `${part[0]}.`).join(" ");
+  if (!last)
+    return initials ?? "";
+  if (!initials)
+    return last;
+  const formatted = initials.replace(/[^A-Za-z]/g, "").split("").map((c) => `${c}.`).join(" ");
+  return `${last}, ${formatted}`;
 }
-
-// src/utils/formatting/markdownBuilder.ts
-class MarkdownBuilder {
-  sections = [];
-  h1(text, emoji3) {
-    const prefix = emoji3 ? `${emoji3} ` : "";
-    this.sections.push(`# ${prefix}${text}
-
-`);
-    return this;
+function formatAuthorsApa(authors) {
+  const formatted = authors.map(formatAuthorApa);
+  if (formatted.length === 0)
+    return "";
+  if (formatted.length === 1)
+    return formatted[0] ?? "";
+  if (formatted.length === 2)
+    return `${formatted[0]}, & ${formatted[1]}`;
+  if (formatted.length <= 20) {
+    const allButLast = formatted.slice(0, -1).join(", ");
+    return `${allButLast}, & ${formatted.at(-1)}`;
   }
-  h2(text, emoji3) {
-    const prefix = emoji3 ? `${emoji3} ` : "";
-    this.sections.push(`## ${prefix}${text}
-
-`);
-    return this;
+  const first19 = formatted.slice(0, 19).join(", ");
+  return `${first19}, ... ${formatted.at(-1)}`;
+}
+function formatAuthorMla(author, isFirst) {
+  if (author.collectiveName)
+    return author.collectiveName;
+  const last = author.lastName ?? "";
+  const first = author.firstName ?? "";
+  if (!last && !first)
+    return "";
+  if (!first)
+    return last;
+  if (!last)
+    return first;
+  return isFirst ? `${last}, ${first}` : `${first} ${last}`;
+}
+function formatAuthorsMla(authors) {
+  const first = authors[0];
+  if (!first)
+    return "";
+  if (authors.length === 1)
+    return formatAuthorMla(first, true);
+  if (authors.length === 2) {
+    const second = authors[1];
+    return second ? `${formatAuthorMla(first, true)}, and ${formatAuthorMla(second, false)}` : formatAuthorMla(first, true);
   }
-  h3(text, emoji3) {
-    const prefix = emoji3 ? `${emoji3} ` : "";
-    this.sections.push(`### ${prefix}${text}
-
-`);
-    return this;
+  return `${formatAuthorMla(first, true)}, et al.`;
+}
+function formatAuthorBibtex(author) {
+  if (author.collectiveName)
+    return `{${escapeBibtex(author.collectiveName)}}`;
+  const last = author.lastName ? escapeBibtex(author.lastName) : "";
+  const first = author.firstName ? escapeBibtex(author.firstName) : "";
+  if (!last && !first)
+    return "";
+  if (!first)
+    return `{${last}}`;
+  if (!last)
+    return first;
+  return `{${last}}, ${first}`;
+}
+function formatApa(article) {
+  const parts = [];
+  const authorStr = article.authors?.length ? formatAuthorsApa(article.authors) : "";
+  if (authorStr) {
+    parts.push(authorStr);
   }
-  h4(text, emoji3) {
-    const prefix = emoji3 ? `${emoji3} ` : "";
-    this.sections.push(`#### ${prefix}${text}
-
-`);
-    return this;
+  const year = getYear(article);
+  parts.push(`(${year}).`);
+  if (article.title) {
+    const title = article.title.replace(/\.\s*$/, "");
+    parts.push(`${title}.`);
   }
-  keyValue(key, value) {
-    const displayValue = value === null ? "null" : String(value);
-    this.sections.push(`**${key}:** ${displayValue}
-`);
-    return this;
+  const journal = article.journalInfo;
+  if (journal?.title) {
+    let journalPart = `*${journal.title}*`;
+    if (journal.volume) {
+      journalPart += `, *${journal.volume}*`;
+      if (journal.issue) {
+        journalPart += `(${journal.issue})`;
+      }
+    }
+    if (journal.pages) {
+      journalPart += `, ${journal.pages}`;
+    }
+    journalPart += ".";
+    parts.push(journalPart);
   }
-  keyValuePlain(key, value) {
-    const displayValue = value === null ? "null" : String(value);
-    this.sections.push(`${key}: ${displayValue}
-`);
-    return this;
+  if (article.doi) {
+    parts.push(`https://doi.org/${article.doi}`);
   }
-  list(items, ordered = false) {
-    if (items.length === 0)
-      return this;
-    const marker = ordered ? (i) => `${i + 1}.` : () => "-";
-    this.sections.push(`${items.map((item, i) => `${marker(i)} ${item}`).join(`
-`)}
-
-`);
-    return this;
+  return parts.join(" ");
+}
+function formatMla(article) {
+  const parts = [];
+  const authorStr = article.authors?.length ? formatAuthorsMla(article.authors) : "";
+  if (authorStr) {
+    parts.push(authorStr.endsWith(".") ? authorStr : `${authorStr}.`);
   }
-  codeBlock(content, language = "") {
-    this.sections.push(`\`\`\`${language}
-${content}
-\`\`\`
-
-`);
-    return this;
+  if (article.title) {
+    const title = article.title.replace(/\.\s*$/, "");
+    parts.push(`"${title}."`);
   }
-  inlineCode(code) {
-    this.sections.push(`\`${code}\``);
-    return this;
+  const journal = article.journalInfo;
+  if (journal?.title) {
+    const detailParts = [];
+    detailParts.push(`*${journal.title}*`);
+    if (journal.volume) {
+      detailParts.push(`vol. ${journal.volume}`);
+    }
+    if (journal.issue) {
+      detailParts.push(`no. ${journal.issue}`);
+    }
+    const year = getYear(article);
+    if (year !== "n.d.") {
+      detailParts.push(year);
+    }
+    if (journal.pages) {
+      detailParts.push(`pp. ${journal.pages}`);
+    }
+    parts.push(`${detailParts.join(", ")}.`);
   }
-  paragraph(text) {
-    this.sections.push(`${text}
-
-`);
-    return this;
+  if (article.doi) {
+    parts.push(`https://doi.org/${article.doi}.`);
   }
-  blockquote(text) {
-    const lines = text.split(`
-`);
-    const quoted = lines.map((line) => `> ${line}`).join(`
-`);
-    this.sections.push(`${quoted}
-
-`);
-    return this;
+  return parts.join(" ");
+}
+function formatBibtex(article) {
+  const key = `pmid${article.pmid}`;
+  const fields = [];
+  if (article.authors?.length) {
+    const authorStr = article.authors.map(formatAuthorBibtex).filter(Boolean).join(" and ");
+    if (authorStr)
+      fields.push(["author", authorStr]);
   }
-  hr() {
-    this.sections.push(`---
-
-`);
-    return this;
+  if (article.title) {
+    fields.push(["title", `{${escapeBibtex(article.title)}}`]);
   }
-  link(text, url2) {
-    this.sections.push(`[${text}](${url2})`);
-    return this;
+  const journal = article.journalInfo;
+  if (journal?.title) {
+    fields.push(["journal", escapeBibtex(journal.title)]);
   }
-  table(headers, rows) {
-    if (headers.length === 0 || rows.length === 0)
-      return this;
-    this.sections.push(`| ${headers.join(" | ")} |
-`);
-    this.sections.push(`| ${headers.map(() => "---").join(" | ")} |
-`);
-    rows.forEach((row) => {
-      this.sections.push(`| ${row.join(" | ")} |
-`);
-    });
-    this.sections.push(`
-`);
-    return this;
+  const year = getYear(article);
+  if (year !== "n.d.") {
+    fields.push(["year", year]);
   }
-  section(title, levelOrContent, content) {
-    let level;
-    let callback;
-    if (typeof levelOrContent === "function") {
-      level = 2;
-      callback = levelOrContent;
-    } else {
-      level = levelOrContent;
-      callback = content ?? (() => {});
-    }
-    switch (level) {
-      case 2:
-        this.h2(title);
-        break;
-      case 3:
-        this.h3(title);
-        break;
-      case 4:
-        this.h4(title);
-        break;
-    }
-    callback();
-    return this;
+  if (journal?.volume) {
+    fields.push(["volume", escapeBibtex(journal.volume)]);
   }
-  details(summary, details) {
-    this.sections.push(`<details>
-<summary>${summary}</summary>
-
-`);
-    this.sections.push(`${details}
-
-`);
-    this.sections.push(`</details>
-
-`);
-    return this;
+  if (journal?.issue) {
+    fields.push(["number", escapeBibtex(journal.issue)]);
   }
-  alert(type, content) {
-    const typeUpper = type.toUpperCase();
-    const lines = content.split(`
-`);
-    this.sections.push(`> [!${typeUpper}]
-`);
-    lines.forEach((line) => {
-      this.sections.push(`> ${line}
-`);
-    });
-    this.sections.push(`
-`);
-    return this;
+  if (journal?.pages) {
+    fields.push(["pages", escapeBibtex(journal.pages)]);
   }
-  taskList(items) {
-    if (items.length === 0)
-      return this;
-    this.sections.push(`${items.map((item) => `- [${item.checked ? "x" : " "}] ${item.text}`).join(`
-`)}
-
-`);
-    return this;
+  if (article.doi) {
+    fields.push(["doi", article.doi]);
   }
-  image(altText, url2, title) {
-    const titlePart = title ? ` "${title}"` : "";
-    this.sections.push(`![${altText}](${url2}${titlePart})
-
+  fields.push(["pmid", article.pmid]);
+  const maxKeyLen = Math.max(...fields.map(([k]) => k.length));
+  const fieldLines = fields.map(([k, v]) => `  ${k.padEnd(maxKeyLen)} = {${v}}`).join(`,
 `);
-    return this;
+  return `@article{${key},
+${fieldLines}
+}`;
+}
+function formatRis(article) {
+  const lines = [];
+  const tag = (code, value) => {
+    if (value)
+      lines.push(`${code}  - ${value}`);
+  };
+  lines.push("TY  - JOUR");
+  if (article.authors?.length) {
+    for (const author of article.authors) {
+      if (author.collectiveName) {
+        tag("AU", author.collectiveName);
+      } else {
+        const last = author.lastName ?? "";
+        const first = author.firstName ?? "";
+        if (last || first) {
+          tag("AU", first ? `${last}, ${first}` : last);
+        }
+      }
+    }
   }
-  strikethrough(text) {
-    this.sections.push(`~~${text}~~`);
-    return this;
+  tag("TI", article.title);
+  const journal = article.journalInfo;
+  if (journal?.title) {
+    tag("JF", journal.title);
   }
-  diff(changes) {
-    const lines = [];
-    if (changes.context) {
-      lines.push(...changes.context.map((line) => `  ${line}`));
-    }
-    if (changes.deletions) {
-      lines.push(...changes.deletions.map((line) => `- ${line}`));
-    }
-    if (changes.additions) {
-      lines.push(...changes.additions.map((line) => `+ ${line}`));
-    }
-    if (lines.length > 0) {
-      this.codeBlock(lines.join(`
-`), "diff");
+  if (journal?.isoAbbreviation) {
+    tag("JO", journal.isoAbbreviation);
+  }
+  const year = getYear(article);
+  if (year !== "n.d.") {
+    tag("PY", year);
+  }
+  tag("VL", journal?.volume);
+  tag("IS", journal?.issue);
+  if (journal?.pages) {
+    const { start, end } = splitPages(journal.pages);
+    tag("SP", start);
+    tag("EP", end);
+  }
+  tag("DO", article.doi);
+  tag("AN", article.pmid);
+  lines.push(`UR  - https://pubmed.ncbi.nlm.nih.gov/${article.pmid}/`);
+  if (article.keywords?.length) {
+    for (const kw of article.keywords) {
+      tag("KW", kw);
     }
-    return this;
   }
-  badge(label, message, color = "blue") {
-    const encodedLabel = encodeURIComponent(label);
-    const encodedMessage = encodeURIComponent(message);
-    const url2 = `https://img.shields.io/badge/${encodedLabel}-${encodedMessage}-${color}`;
-    this.sections.push(`![${label}: ${message}](${url2})`);
-    return this;
+  tag("AB", article.abstractText);
+  lines.push("ER  - ");
+  return lines.join(`
+`);
+}
+function formatCitation(article, style) {
+  switch (style) {
+    case "apa":
+      return formatApa(article);
+    case "mla":
+      return formatMla(article);
+    case "bibtex":
+      return formatBibtex(article);
+    case "ris":
+      return formatRis(article);
   }
-  bold(text) {
-    this.sections.push(`**${text}**`);
-    return this;
+}
+function formatCitations(article, styles) {
+  const result = {};
+  for (const style of styles) {
+    result[style] = formatCitation(article, style);
   }
-  italic(text) {
-    this.sections.push(`*${text}*`);
-    return this;
+  return result;
+}
+
+// src/services/ncbi/parsing/article-parser.ts
+function extractAuthors(authorListXml) {
+  if (!authorListXml)
+    return { authors: [], affiliations: [] };
+  const affiliationMap = new Map;
+  const affiliationList = [];
+  function getAffiliationIndex(text) {
+    const existing = affiliationMap.get(text);
+    if (existing !== undefined)
+      return existing;
+    const idx = affiliationList.length;
+    affiliationList.push(text);
+    affiliationMap.set(text, idx);
+    return idx;
   }
-  boldItalic(text) {
-    this.sections.push(`***${text}***`);
-    return this;
+  const xmlAuthors = ensureArray(authorListXml.Author);
+  const authors = xmlAuthors.map((auth) => {
+    const collectiveName = getText(auth.CollectiveName);
+    if (collectiveName) {
+      return { collectiveName };
+    }
+    const authorAffiliationInfos = ensureArray(auth.AffiliationInfo);
+    const indices = [];
+    for (const info of authorAffiliationInfos) {
+      const text = getText(info?.Affiliation);
+      if (text)
+        indices.push(getAffiliationIndex(text));
+    }
+    let orcid;
+    const identifiers = ensureArray(auth.Identifier);
+    for (const id of identifiers) {
+      if (getAttribute(id, "Source") === "ORCID") {
+        const val = getText(id);
+        if (val) {
+          orcid = val;
+          break;
+        }
+      }
+    }
+    return {
+      lastName: getText(auth.LastName),
+      firstName: getText(auth.ForeName),
+      initials: getText(auth.Initials),
+      ...indices.length > 0 && { affiliationIndices: indices },
+      ...orcid && { orcid }
+    };
+  });
+  return { authors, affiliations: affiliationList };
+}
+function extractJournalInfo(journalXml, articleXml) {
+  if (!journalXml)
+    return;
+  const pubDate = journalXml.JournalIssue?.PubDate;
+  const year = getText(pubDate?.Year, getText(pubDate?.MedlineDate, "").match(/\d{4}/)?.[0]);
+  const issnElement = journalXml.ISSN;
+  const issnValue = getText(issnElement);
+  const issnType = getAttribute(issnElement, "IssnType");
+  const issn = issnType === "Electronic" ? undefined : issnValue || undefined;
+  const eIssn = issnType === "Electronic" ? issnValue || undefined : undefined;
+  return {
+    title: getText(journalXml.Title),
+    isoAbbreviation: getText(journalXml.ISOAbbreviation),
+    ...issn && { issn },
+    ...eIssn && { eIssn },
+    volume: getText(journalXml.JournalIssue?.Volume),
+    issue: getText(journalXml.JournalIssue?.Issue),
+    pages: getText(articleXml?.Pagination?.MedlinePgn),
+    publicationDate: {
+      ...year && { year },
+      ...getText(pubDate?.Month) && { month: getText(pubDate?.Month) },
+      ...getText(pubDate?.Day) && { day: getText(pubDate?.Day) },
+      ...getText(pubDate?.MedlineDate) && { medlineDate: getText(pubDate?.MedlineDate) }
+    }
+  };
+}
+function extractMeshTerms(meshHeadingListXml) {
+  if (!meshHeadingListXml)
+    return [];
+  const meshHeadings = ensureArray(meshHeadingListXml.MeshHeading);
+  return meshHeadings.map((mh) => {
+    const isMajorDescriptor = getAttribute(mh.DescriptorName, "MajorTopicYN") === "Y";
+    const isMajorRoot = getAttribute(mh, "MajorTopicYN") === "Y";
+    const descriptorUi = getAttribute(mh.DescriptorName, "UI");
+    const rawQualifiers = ensureArray(mh.QualifierName);
+    const qualifiers = rawQualifiers.flatMap((q) => {
+      const name = getText(q);
+      if (!name)
+        return [];
+      const ui = getAttribute(q, "UI");
+      return {
+        qualifierName: name,
+        ...ui && { qualifierUi: ui },
+        isMajorTopic: getAttribute(q, "MajorTopicYN") === "Y"
+      };
+    });
+    const isMajorAnyQualifier = qualifiers.some((q) => q.isMajorTopic);
+    return {
+      descriptorName: getText(mh.DescriptorName),
+      ...descriptorUi && { descriptorUi },
+      ...qualifiers.length > 0 && { qualifiers },
+      isMajorTopic: isMajorRoot || isMajorDescriptor || isMajorAnyQualifier
+    };
+  });
+}
+function extractGrants(grantListXml) {
+  if (!grantListXml)
+    return [];
+  const grants = ensureArray(grantListXml.Grant);
+  return grants.map((g) => {
+    const grantId = getText(g.GrantID);
+    const acronym = getText(g.Acronym);
+    const agency = getText(g.Agency);
+    const country = getText(g.Country);
+    return {
+      ...grantId && { grantId },
+      ...acronym && { acronym },
+      ...agency && { agency },
+      ...country && { country }
+    };
+  });
+}
+function extractDoi(articleXml, pubmedDataArticleIdList) {
+  if (!articleXml)
+    return;
+  const eLocationIDs = ensureArray(articleXml.ELocationID);
+  for (const eloc of eLocationIDs) {
+    if (getAttribute(eloc, "EIdType") === "doi" && getAttribute(eloc, "ValidYN") === "Y") {
+      const doi = getText(eloc);
+      if (doi)
+        return doi;
+    }
   }
-  raw(markdown) {
-    this.sections.push(markdown);
-    return this;
+  for (const eloc of eLocationIDs) {
+    if (getAttribute(eloc, "EIdType") === "doi") {
+      const doi = getText(eloc);
+      if (doi)
+        return doi;
+    }
   }
-  blankLine() {
-    this.sections.push(`
-`);
-    return this;
+  const articleIds = ensureArray(articleXml.ArticleIdList?.ArticleId);
+  for (const aid of articleIds) {
+    if (getAttribute(aid, "IdType") === "doi") {
+      const doi = getText(aid);
+      if (doi)
+        return doi;
+    }
   }
-  text(text) {
-    this.sections.push(text);
-    return this;
+  if (pubmedDataArticleIdList) {
+    const pubmedDataIds = ensureArray(pubmedDataArticleIdList.ArticleId);
+    for (const aid of pubmedDataIds) {
+      if (getAttribute(aid, "IdType") === "doi") {
+        const doi = getText(aid);
+        if (doi)
+          return doi;
+      }
+    }
   }
-  when(condition, content) {
-    if (condition) {
-      content();
+  return;
+}
+function extractPmcId(articleXml, pubmedDataArticleIdList) {
+  const articleIds = ensureArray(articleXml?.ArticleIdList?.ArticleId);
+  for (const aid of articleIds) {
+    if (getAttribute(aid, "IdType") === "pmc") {
+      const val = getText(aid);
+      if (val)
+        return val;
     }
-    return this;
   }
-  build() {
-    return this.sections.join("").trim();
+  if (pubmedDataArticleIdList) {
+    const pubmedDataIds = ensureArray(pubmedDataArticleIdList.ArticleId);
+    for (const aid of pubmedDataIds) {
+      if (getAttribute(aid, "IdType") === "pmc") {
+        const val = getText(aid);
+        if (val)
+          return val;
+      }
+    }
   }
-  reset() {
-    this.sections = [];
-    return this;
+  return;
+}
+function extractPublicationTypes(publicationTypeListXml) {
+  if (!publicationTypeListXml)
+    return [];
+  const pubTypes = ensureArray(publicationTypeListXml.PublicationType);
+  return pubTypes.map((pt) => getText(pt)).filter(Boolean);
+}
+function extractKeywords2(keywordListsXml) {
+  if (!keywordListsXml)
+    return [];
+  const lists = ensureArray(keywordListsXml);
+  const allKeywords = [];
+  for (const list of lists) {
+    for (const kw of ensureArray(list.Keyword)) {
+      const keywordText = getText(kw);
+      if (keywordText) {
+        allKeywords.push(keywordText);
+      }
+    }
   }
+  return allKeywords;
 }
-function markdown() {
-  return new MarkdownBuilder;
+function extractAbstractText(abstractXml) {
+  if (!abstractXml || !abstractXml.AbstractText)
+    return;
+  const abstractTexts = ensureArray(abstractXml.AbstractText);
+  if (abstractTexts.length === 0)
+    return;
+  const processedTexts = abstractTexts.map((at) => {
+    if (typeof at === "string") {
+      return at;
+    }
+    const sectionText = getText(at);
+    const label = getAttribute(at, "Label");
+    if (label && sectionText) {
+      return `${label.trim()}: ${sectionText.trim()}`;
+    }
+    return sectionText.trim();
+  }).filter(Boolean);
+  if (processedTexts.length === 0)
+    return;
+  return processedTexts.join(`
+
+`).trim() || undefined;
+}
+function extractPmid(medlineCitationXml) {
+  if (!medlineCitationXml || !medlineCitationXml.PMID)
+    return;
+  return getText(medlineCitationXml.PMID);
+}
+function extractArticleDates(articleXml) {
+  if (!articleXml || !articleXml.ArticleDate)
+    return [];
+  const articleDatesXml = ensureArray(articleXml.ArticleDate);
+  return articleDatesXml.map((ad) => ({
+    dateType: getAttribute(ad, "DateType"),
+    year: getText(ad.Year),
+    month: getText(ad.Month),
+    day: getText(ad.Day)
+  }));
+}
+function parseFullArticle(xmlArticle, options = {}) {
+  const medlineCitation = xmlArticle.MedlineCitation;
+  const article = medlineCitation?.Article;
+  const { includeMesh = true, includeGrants = false } = options;
+  const abstractText = extractAbstractText(article?.Abstract);
+  const journalInfo = extractJournalInfo(article?.Journal, article);
+  const pubmedDataArticleIdList = xmlArticle.PubmedData?.ArticleIdList;
+  const doi = extractDoi(article, pubmedDataArticleIdList);
+  const pmcId = extractPmcId(article, pubmedDataArticleIdList);
+  const { authors, affiliations } = extractAuthors(article?.AuthorList);
+  return {
+    pmid: extractPmid(medlineCitation) ?? "",
+    title: getText(article?.ArticleTitle),
+    ...abstractText !== undefined && { abstractText },
+    ...affiliations.length > 0 && { affiliations },
+    authors,
+    ...journalInfo !== undefined && { journalInfo },
+    publicationTypes: extractPublicationTypes(article?.PublicationTypeList),
+    keywords: extractKeywords2(medlineCitation?.KeywordList ?? article?.KeywordList),
+    ...includeMesh && { meshTerms: extractMeshTerms(medlineCitation?.MeshHeadingList) },
+    ...includeGrants && { grantList: extractGrants(article?.GrantList) },
+    ...doi !== undefined && { doi },
+    ...pmcId !== undefined && { pmcId },
+    articleDates: extractArticleDates(article)
+  };
 }
 
 // src/mcp-server/tools/definitions/pubmed-cite.tool.ts
-var ncbi2 = () => container.resolve(NcbiServiceToken);
-var TOOL_NAME = "pubmed_cite";
-var TOOL_TITLE = "PubMed Citations";
-var TOOL_DESCRIPTION = "Get formatted citations for PubMed articles in APA, MLA, BibTeX, or RIS format.";
-var TOOL_ANNOTATIONS = {
+var ncbi3 = () => container.resolve(NcbiServiceToken);
+var TOOL_NAME2 = "pubmed_cite";
+var TOOL_TITLE2 = "PubMed Citations";
+var TOOL_DESCRIPTION2 = "Get formatted citations for PubMed articles in APA, MLA, BibTeX, or RIS format.";
+var TOOL_ANNOTATIONS2 = {
   readOnlyHint: true,
   idempotentHint: true,
   openWorldHint: true
 };
-var InputSchema = exports_external.object({
+var InputSchema2 = exports_external.object({
   pmids: exports_external.array(exports_external.string().regex(/^\d+$/)).min(1).max(50).describe("PubMed IDs to cite"),
   styles: exports_external.array(exports_external.enum(["apa", "mla", "bibtex", "ris"])).default(["apa"]).describe("Citation styles to generate")
 });
-var OutputSchema2 = exports_external.object({
+var OutputSchema3 = exports_external.object({
   citations: exports_external.array(exports_external.object({
     pmid: exports_external.string(),
     title: exports_external.string().optional(),
     citations: exports_external.record(exports_external.string(), exports_external.string())
   })).describe("Citations per article")
 });
-async function logic(input, appContext, _sdkContext) {
+async function logic2(input, appContext, _sdkContext) {
   logger.debug("Fetching articles for citation generation", {
     ...appContext,
     pmids: input.pmids,
     styles: input.styles
   });
-  const raw = await ncbi2().eFetch({ db: "pubmed", id: input.pmids.join(",") }, appContext);
+  const raw = await ncbi3().eFetch({ db: "pubmed", id: input.pmids.join(",") }, appContext);
   const xmlArticles = ensureArray(raw?.PubmedArticleSet?.PubmedArticle);
   if (xmlArticles.length === 0) {
     throw new McpError(-32001 /* NotFound */, `No articles found for PMIDs: ${input.pmids.join(", ")}`, { requestId: appContext.requestId });
@@ -151590,7 +152100,7 @@ async function logic(input, appContext, _sdkContext) {
   });
   return { citations };
 }
-function responseFormatter(result) {
+function responseFormatter2(result) {
   const md = markdown();
   md.text(`# PubMed Citations
 `);
@@ -151617,32 +152127,32 @@ ${citation}
   return [{ type: "text", text: md.build() }];
 }
 var pubmedCiteTool = {
-  name: TOOL_NAME,
-  title: TOOL_TITLE,
-  description: TOOL_DESCRIPTION,
-  annotations: TOOL_ANNOTATIONS,
-  inputSchema: InputSchema,
-  outputSchema: OutputSchema2,
-  logic: withToolAuth(["tool:pubmed_cite:read"], logic),
-  responseFormatter
+  name: TOOL_NAME2,
+  title: TOOL_TITLE2,
+  description: TOOL_DESCRIPTION2,
+  annotations: TOOL_ANNOTATIONS2,
+  inputSchema: InputSchema2,
+  outputSchema: OutputSchema3,
+  logic: withToolAuth(["tool:pubmed_cite:read"], logic2),
+  responseFormatter: responseFormatter2
 };
 
 // src/mcp-server/tools/definitions/pubmed-fetch.tool.ts
-var ncbi3 = () => container.resolve(NcbiServiceToken);
-var TOOL_NAME2 = "pubmed_fetch";
-var TOOL_TITLE2 = "PubMed Fetch";
-var TOOL_DESCRIPTION2 = "Fetch full article metadata by PubMed IDs. Returns detailed article information including abstract, authors, journal, MeSH terms.";
-var TOOL_ANNOTATIONS2 = {
+var ncbi4 = () => container.resolve(NcbiServiceToken);
+var TOOL_NAME3 = "pubmed_fetch";
+var TOOL_TITLE3 = "PubMed Fetch";
+var TOOL_DESCRIPTION3 = "Fetch full article metadata by PubMed IDs. Returns detailed article information including abstract, authors, journal, MeSH terms.";
+var TOOL_ANNOTATIONS3 = {
   readOnlyHint: true,
   idempotentHint: true,
   openWorldHint: true
 };
-var InputSchema2 = exports_external.object({
+var InputSchema3 = exports_external.object({
   pmids: exports_external.array(exports_external.string().regex(/^\d+$/)).min(1).max(200).describe("PubMed IDs to fetch"),
   includeMesh: exports_external.boolean().default(true).describe("Include MeSH terms"),
   includeGrants: exports_external.boolean().default(false).describe("Include grant information")
 });
-var ArticleSchema = exports_external.object({
+var ArticleSchema2 = exports_external.object({
   pmid: exports_external.string().optional().describe("PubMed ID"),
   title: exports_external.string().optional().describe("Article title"),
   abstractText: exports_external.string().optional().describe("Abstract text"),
@@ -151657,16 +152167,16 @@ var ArticleSchema = exports_external.object({
   meshTerms: exports_external.array(exports_external.any()).optional().describe("MeSH terms"),
   grantList: exports_external.array(exports_external.any()).optional().describe("Grant information")
 });
-var OutputSchema3 = exports_external.object({
-  articles: exports_external.array(ArticleSchema).describe("Parsed articles"),
+var OutputSchema4 = exports_external.object({
+  articles: exports_external.array(ArticleSchema2).describe("Parsed articles"),
   totalReturned: exports_external.number().describe("Number of articles returned")
 });
-async function logic2(input, appContext, _sdkContext) {
+async function logic3(input, appContext, _sdkContext) {
   logger.info("Executing pubmed_fetch tool", {
     ...appContext,
     pmidCount: input.pmids.length
   });
-  const xmlData = await ncbi3().eFetch({ db: "pubmed", id: input.pmids.join(","), retmode: "xml" }, appContext, { retmode: "xml", usePost: input.pmids.length > 200 });
+  const xmlData = await ncbi4().eFetch({ db: "pubmed", id: input.pmids.join(","), retmode: "xml" }, appContext, { retmode: "xml", usePost: input.pmids.length > 200 });
   if (!xmlData || !("PubmedArticleSet" in xmlData)) {
     throw new McpError(-32603 /* InternalError */, "Invalid EFetch response from NCBI: missing PubmedArticleSet", { requestId: appContext.requestId });
   }
@@ -151694,7 +152204,7 @@ async function logic2(input, appContext, _sdkContext) {
   });
   return { articles, totalReturned: articles.length };
 }
-function responseFormatter2(result) {
+function responseFormatter3(result) {
   const md = markdown().h2("PubMed Articles").keyValue("Articles Returned", result.totalReturned);
   for (const article of result.articles) {
     md.h3(article.title ?? article.pmid ?? "Unknown");
@@ -151729,27 +152239,27 @@ function responseFormatter2(result) {
   return [{ type: "text", text: md.build() }];
 }
 var pubmedFetchTool = {
-  name: TOOL_NAME2,
-  title: TOOL_TITLE2,
-  description: TOOL_DESCRIPTION2,
-  annotations: TOOL_ANNOTATIONS2,
-  inputSchema: InputSchema2,
-  outputSchema: OutputSchema3,
-  logic: withToolAuth(["tool:pubmed_fetch:read"], logic2),
-  responseFormatter: responseFormatter2
+  name: TOOL_NAME3,
+  title: TOOL_TITLE3,
+  description: TOOL_DESCRIPTION3,
+  annotations: TOOL_ANNOTATIONS3,
+  inputSchema: InputSchema3,
+  outputSchema: OutputSchema4,
+  logic: withToolAuth(["tool:pubmed_fetch:read"], logic3),
+  responseFormatter: responseFormatter3
 };
 
 // src/mcp-server/tools/definitions/pubmed-mesh-lookup.tool.ts
-var ncbi4 = () => container.resolve(NcbiServiceToken);
-var TOOL_NAME3 = "pubmed_mesh_lookup";
-var TOOL_TITLE3 = "MeSH Term Lookup";
-var TOOL_DESCRIPTION3 = "Search and explore MeSH (Medical Subject Headings) vocabulary. Essential for building precise PubMed queries.";
-var TOOL_ANNOTATIONS3 = {
+var ncbi5 = () => container.resolve(NcbiServiceToken);
+var TOOL_NAME4 = "pubmed_mesh_lookup";
+var TOOL_TITLE4 = "MeSH Term Lookup";
+var TOOL_DESCRIPTION4 = "Search and explore MeSH (Medical Subject Headings) vocabulary. Essential for building precise PubMed queries.";
+var TOOL_ANNOTATIONS4 = {
   readOnlyHint: true,
   idempotentHint: true,
   openWorldHint: true
 };
-var InputSchema3 = exports_external.object({
+var InputSchema4 = exports_external.object({
   term: exports_external.string().min(1).describe("MeSH term to look up"),
   maxResults: exports_external.number().int().min(1).max(50).default(10).describe("Maximum results"),
   includeDetails: exports_external.boolean().default(true).describe("Fetch full MeSH records (scope notes, tree numbers, entry terms)")
@@ -151761,7 +152271,7 @@ var MeshResultItem = exports_external.object({
   scopeNote: exports_external.string().optional().describe("Scope note describing the descriptor"),
   entryTerms: exports_external.array(exports_external.string()).optional().describe("Synonyms / entry terms")
 });
-var OutputSchema4 = exports_external.object({
+var OutputSchema5 = exports_external.object({
   term: exports_external.string().describe("Original search term"),
   results: exports_external.array(MeshResultItem).describe("Matching MeSH records")
 });
@@ -151831,8 +152341,8 @@ async function meshLookupLogic(input, context, _sdkContext) {
   const { term, maxResults, includeDetails } = input;
   logger.debug("MeSH lookup started.", { ...context, term, maxResults, includeDetails });
   const hasFieldTag = /\[.+\]/.test(term);
-  const broadSearch = ncbi4().eSearch({ db: "mesh", term, retmax: maxResults }, context);
-  const exactSearch = hasFieldTag ? undefined : ncbi4().eSearch({ db: "mesh", term: `${term}[MH]`, retmax: 1 }, context);
+  const broadSearch = ncbi5().eSearch({ db: "mesh", term, retmax: maxResults }, context);
+  const exactSearch = hasFieldTag ? undefined : ncbi5().eSearch({ db: "mesh", term: `${term}[MH]`, retmax: 1 }, context);
   const [broadResult, exactResult] = await Promise.all([broadSearch, exactSearch]);
   const seen = new Set;
   const ids = [];
@@ -151847,7 +152357,7 @@ async function meshLookupLogic(input, context, _sdkContext) {
     logger.debug("No MeSH results found.", { ...context, term });
     return { term, results: [] };
   }
-  const summaryData = await ncbi4().eSummary({ db: "mesh", id: ids.join(",") }, context);
+  const summaryData = await ncbi5().eSummary({ db: "mesh", id: ids.join(",") }, context);
   const results = parseSummaryRecords(summaryData, ids, includeDetails);
   const termLower = term.toLowerCase();
   results.sort((a, b) => {
@@ -151894,12 +152404,12 @@ function formatResponse(result) {
   return [{ type: "text", text: md.build() }];
 }
 var pubmedMeshLookupTool = {
-  name: TOOL_NAME3,
-  title: TOOL_TITLE3,
-  description: TOOL_DESCRIPTION3,
-  annotations: TOOL_ANNOTATIONS3,
-  inputSchema: InputSchema3,
-  outputSchema: OutputSchema4,
+  name: TOOL_NAME4,
+  title: TOOL_TITLE4,
+  description: TOOL_DESCRIPTION4,
+  annotations: TOOL_ANNOTATIONS4,
+  inputSchema: InputSchema4,
+  outputSchema: OutputSchema5,
   logic: withToolAuth(["tool:pubmed_mesh_lookup:read"], meshLookupLogic),
   responseFormatter: formatResponse
 };
@@ -155051,21 +155561,21 @@ async function extractBriefSummaries(eSummaryResult, context) {
 }
 
 // src/mcp-server/tools/definitions/pubmed-related.tool.ts
-var ncbi5 = () => container.resolve(NcbiServiceToken);
-var TOOL_NAME4 = "pubmed_related";
-var TOOL_TITLE4 = "PubMed Related Articles";
-var TOOL_DESCRIPTION4 = "Find articles related to a source article — similar content, citing articles, or references.";
-var TOOL_ANNOTATIONS4 = {
+var ncbi6 = () => container.resolve(NcbiServiceToken);
+var TOOL_NAME5 = "pubmed_related";
+var TOOL_TITLE5 = "PubMed Related Articles";
+var TOOL_DESCRIPTION5 = "Find articles related to a source article — similar content, citing articles, or references.";
+var TOOL_ANNOTATIONS5 = {
   readOnlyHint: true,
   idempotentHint: true,
   openWorldHint: true
 };
-var InputSchema4 = exports_external.object({
+var InputSchema5 = exports_external.object({
   pmid: exports_external.string().regex(/^\d+$/).describe("Source PubMed ID"),
   relationship: exports_external.enum(["similar", "cited_by", "references"]).default("similar").describe("Type of relationship"),
   maxResults: exports_external.number().int().min(1).max(50).default(10).describe("Maximum related articles")
 });
-var OutputSchema5 = exports_external.object({
+var OutputSchema6 = exports_external.object({
   sourcePmid: exports_external.string().describe("Source PubMed ID"),
   relationship: exports_external.string().describe("Relationship type used"),
   articles: exports_external.array(exports_external.object({
@@ -155084,7 +155594,7 @@ function extractValue(field) {
   }
   return String(field);
 }
-async function logic3(input, appContext, _sdkContext) {
+async function logic4(input, appContext, _sdkContext) {
   logger.debug("Finding related articles", {
     ...appContext,
     pmid: input.pmid,
@@ -155109,7 +155619,7 @@ async function logic3(input, appContext, _sdkContext) {
       eLinkParams.linkname = "pubmed_pubmed_refs";
       break;
   }
-  const eLinkResult = await ncbi5().eLink(eLinkParams, appContext);
+  const eLinkResult = await ncbi6().eLink(eLinkParams, appContext);
   logger.debug("Raw ELink response received", {
     ...appContext,
     hasResult: !!eLinkResult?.eLinkResult
@@ -155151,7 +155661,7 @@ async function logic3(input, appContext, _sdkContext) {
   }
   const pmidsToEnrich = foundPmids.slice(0, input.maxResults);
   const pmidIds = pmidsToEnrich.map((p) => p.pmid);
-  const summaryResult = await ncbi5().eSummary({ db: "pubmed", id: pmidIds.join(",") }, appContext);
+  const summaryResult = await ncbi6().eSummary({ db: "pubmed", id: pmidIds.join(",") }, appContext);
   const briefSummaries = await extractBriefSummaries(summaryResult, appContext);
   const summaryMap = new Map(briefSummaries.map((bs) => [bs.pmid, bs]));
   const articles = pmidsToEnrich.map((p) => {
@@ -155175,7 +155685,7 @@ async function logic3(input, appContext, _sdkContext) {
     totalFound
   };
 }
-function responseFormatter3(result) {
+function responseFormatter4(result) {
   const md = markdown();
   md.text(`# Related Articles for PMID ${result.sourcePmid}
 `);
@@ -155198,27 +155708,27 @@ function responseFormatter3(result) {
   return [{ type: "text", text: md.build() }];
 }
 var pubmedRelatedTool = {
-  name: TOOL_NAME4,
-  title: TOOL_TITLE4,
-  description: TOOL_DESCRIPTION4,
-  annotations: TOOL_ANNOTATIONS4,
-  inputSchema: InputSchema4,
-  outputSchema: OutputSchema5,
-  logic: withToolAuth(["tool:pubmed_related:read"], logic3),
-  responseFormatter: responseFormatter3
+  name: TOOL_NAME5,
+  title: TOOL_TITLE5,
+  description: TOOL_DESCRIPTION5,
+  annotations: TOOL_ANNOTATIONS5,
+  inputSchema: InputSchema5,
+  outputSchema: OutputSchema6,
+  logic: withToolAuth(["tool:pubmed_related:read"], logic4),
+  responseFormatter: responseFormatter4
 };
 
 // src/mcp-server/tools/definitions/pubmed-search.tool.ts
-var ncbi6 = () => container.resolve(NcbiServiceToken);
-var TOOL_NAME5 = "pubmed_search";
-var TOOL_TITLE5 = "PubMed Search";
-var TOOL_DESCRIPTION5 = "Search PubMed with full query syntax, filters, and date ranges. Returns PMIDs and optional brief summaries. " + "Supports field-specific filters (author, journal, MeSH terms), common filters (language, species, free full text), " + "and pagination via offset for paging through large result sets.";
-var TOOL_ANNOTATIONS5 = {
+var ncbi7 = () => container.resolve(NcbiServiceToken);
+var TOOL_NAME6 = "pubmed_search";
+var TOOL_TITLE6 = "PubMed Search";
+var TOOL_DESCRIPTION6 = "Search PubMed with full query syntax, filters, and date ranges. Returns PMIDs and optional brief summaries. " + "Supports field-specific filters (author, journal, MeSH terms), common filters (language, species, free full text), " + "and pagination via offset for paging through large result sets.";
+var TOOL_ANNOTATIONS6 = {
   readOnlyHint: true,
   idempotentHint: true,
   openWorldHint: true
 };
-var InputSchema5 = exports_external.object({
+var InputSchema6 = exports_external.object({
   query: exports_external.string().min(1).describe("PubMed search query (supports full NCBI syntax)"),
   maxResults: exports_external.number().int().min(1).max(1000).default(20).describe("Maximum results to return"),
   offset: exports_external.number().int().min(0).default(0).describe("Result offset for pagination (0-based). Use with maxResults to page through results"),
@@ -155238,7 +155748,7 @@ var InputSchema5 = exports_external.object({
   species: exports_external.enum(["humans", "animals"]).optional().describe("Filter by species"),
   summaryCount: exports_external.number().int().min(0).max(50).default(0).describe("Fetch brief summaries for top N results (0 = PMIDs only)")
 });
-var OutputSchema6 = exports_external.object({
+var OutputSchema7 = exports_external.object({
   query: exports_external.string().describe("Original query"),
   totalFound: exports_external.number().describe("Total matching articles"),
   offset: exports_external.number().describe("Result offset used"),
@@ -155256,7 +155766,7 @@ var OutputSchema6 = exports_external.object({
   })).optional().describe("Brief summaries"),
   searchUrl: exports_external.string().describe("PubMed search URL")
 });
-async function logic4(input, appContext, _sdkContext) {
+async function logic5(input, appContext, _sdkContext) {
   logger.info("Executing pubmed_search tool", { ...appContext, query: input.query });
   let effectiveQuery = sanitization.sanitizeString(input.query, { context: "text" });
   if (input.dateRange) {
@@ -155291,7 +155801,7 @@ async function logic4(input, appContext, _sdkContext) {
   if (input.species) {
     effectiveQuery += ` AND ${input.species}[MeSH Terms]`;
   }
-  const esResult = await ncbi6().eSearch({
+  const esResult = await ncbi7().eSearch({
     db: "pubmed",
     term: effectiveQuery,
     retmax: input.maxResults,
@@ -155315,7 +155825,7 @@ async function logic4(input, appContext, _sdkContext) {
     } else {
       eSummaryParams.id = pmids.slice(0, input.summaryCount).join(",");
     }
-    const eSummaryResult = await ncbi6().eSummary(eSummaryParams, appContext);
+    const eSummaryResult = await ncbi7().eSummary(eSummaryParams, appContext);
     if (eSummaryResult) {
       const briefSummaries = await extractBriefSummaries(eSummaryResult, appContext);
       summaries = briefSummaries.map((s) => ({
@@ -155340,7 +155850,7 @@ async function logic4(input, appContext, _sdkContext) {
   });
   return { query: input.query, totalFound, offset: input.offset, pmids, summaries, searchUrl };
 }
-function responseFormatter4(result) {
+function responseFormatter5(result) {
   const md = markdown().h2("PubMed Search Results").keyValue("Query", result.query).keyValue("Total Found", result.totalFound).keyValue("Offset", result.offset).keyValue("PMIDs Returned", result.pmids.length).keyValue("Search URL", result.searchUrl);
   if (result.pmids.length > 0) {
     md.h3("PMIDs").paragraph(result.pmids.join(", "));
@@ -155367,37 +155877,37 @@ function responseFormatter4(result) {
   return [{ type: "text", text: md.build() }];
 }
 var pubmedSearchTool = {
-  name: TOOL_NAME5,
-  title: TOOL_TITLE5,
-  description: TOOL_DESCRIPTION5,
-  annotations: TOOL_ANNOTATIONS5,
-  inputSchema: InputSchema5,
-  outputSchema: OutputSchema6,
-  logic: withToolAuth(["tool:pubmed_search:read"], logic4),
-  responseFormatter: responseFormatter4
+  name: TOOL_NAME6,
+  title: TOOL_TITLE6,
+  description: TOOL_DESCRIPTION6,
+  annotations: TOOL_ANNOTATIONS6,
+  inputSchema: InputSchema6,
+  outputSchema: OutputSchema7,
+  logic: withToolAuth(["tool:pubmed_search:read"], logic5),
+  responseFormatter: responseFormatter5
 };
 
 // src/mcp-server/tools/definitions/pubmed-spell.tool.ts
-var ncbi7 = () => container.resolve(NcbiServiceToken);
-var TOOL_NAME6 = "pubmed_spell";
-var TOOL_TITLE6 = "PubMed Spell Check";
-var TOOL_DESCRIPTION6 = "Spell-check a query and get NCBI's suggested correction. Useful for refining search queries.";
-var TOOL_ANNOTATIONS6 = {
+var ncbi8 = () => container.resolve(NcbiServiceToken);
+var TOOL_NAME7 = "pubmed_spell";
+var TOOL_TITLE7 = "PubMed Spell Check";
+var TOOL_DESCRIPTION7 = "Spell-check a query and get NCBI's suggested correction. Useful for refining search queries.";
+var TOOL_ANNOTATIONS7 = {
   readOnlyHint: true,
   idempotentHint: true,
   openWorldHint: true
 };
-var InputSchema6 = exports_external.object({
+var InputSchema7 = exports_external.object({
   query: exports_external.string().min(2).describe("Query to spell-check")
 });
-var OutputSchema7 = exports_external.object({
+var OutputSchema8 = exports_external.object({
   original: exports_external.string().describe("Original query"),
   corrected: exports_external.string().describe("Corrected query (same as original if no suggestion)"),
   hasSuggestion: exports_external.boolean().describe("Whether NCBI suggested a correction")
 });
-async function logic5(input, appContext, _sdkContext) {
+async function logic6(input, appContext, _sdkContext) {
   logger.info("Executing pubmed_spell tool", { ...appContext, query: input.query });
-  const result = await ncbi7().eSpell({ db: "pubmed", term: input.query }, appContext);
+  const result = await ncbi8().eSpell({ db: "pubmed", term: input.query }, appContext);
   logger.notice("pubmed_spell completed", {
     ...appContext,
     hasSuggestion: result.hasSuggestion
@@ -155408,7 +155918,7 @@ async function logic5(input, appContext, _sdkContext) {
     hasSuggestion: result.hasSuggestion
   };
 }
-function responseFormatter5(result) {
+function responseFormatter6(result) {
   const md = markdown().h2("PubMed Spell Check");
   if (result.hasSuggestion) {
     md.keyValue("Original", result.original).keyValue("Suggested", result.corrected);
@@ -155418,20 +155928,21 @@ function responseFormatter5(result) {
   return [{ type: "text", text: md.build() }];
 }
 var pubmedSpellTool = {
-  name: TOOL_NAME6,
-  title: TOOL_TITLE6,
-  description: TOOL_DESCRIPTION6,
-  annotations: TOOL_ANNOTATIONS6,
-  inputSchema: InputSchema6,
-  outputSchema: OutputSchema7,
-  logic: withToolAuth(["tool:pubmed_spell:read"], logic5),
-  responseFormatter: responseFormatter5
+  name: TOOL_NAME7,
+  title: TOOL_TITLE7,
+  description: TOOL_DESCRIPTION7,
+  annotations: TOOL_ANNOTATIONS7,
+  inputSchema: InputSchema7,
+  outputSchema: OutputSchema8,
+  logic: withToolAuth(["tool:pubmed_spell:read"], logic6),
+  responseFormatter: responseFormatter6
 };
 
 // src/mcp-server/tools/definitions/index.ts
 var allToolDefinitions = [
   pubmedSearchTool,
   pubmedFetchTool,
+  pmcFetchTool,
   pubmedSpellTool,
   pubmedCiteTool,
   pubmedRelatedTool,
@@ -155633,8 +156144,8 @@ var defaultResponseFormatter2 = (result) => [
 function createMcpToolHandler({
   toolName,
   inputSchema,
-  logic: logic6,
-  responseFormatter: responseFormatter6 = defaultResponseFormatter2
+  logic: logic7,
+  responseFormatter: responseFormatter7 = defaultResponseFormatter2
 }) {
   return async (input, callContext) => {
     const sdkContext = callContext;
@@ -155649,10 +156160,10 @@ function createMcpToolHandler({
     });
     try {
       const validatedInput = inputSchema.parse(input);
-      const result = await measureToolExecution(() => logic6(validatedInput, appContext, sdkContext), { ...appContext, toolName }, validatedInput);
+      const result = await measureToolExecution(() => logic7(validatedInput, appContext, sdkContext), { ...appContext, toolName }, validatedInput);
       return {
         structuredContent: result,
-        content: responseFormatter6(result)
+        content: responseFormatter7(result)
       };
     } catch (error48) {
       const handled = ErrorHandler.handleError(error48, {