@cyanheads/pubmed-mcp-server 2.9.8 → 2.9.10

package/dist/mcp-server/tools/definitions/fetch-fulltext.tool.js

@@ -64,6 +64,18 @@ function applyPmcFilters(article, filters) {
 function isSectionFilterMiss(before, after, sectionFilter) {
     return (Boolean(sectionFilter?.length) && before.sections.length > 0 && after.sections.length === 0);
 }
+/**
+ * True when the upstream JATS carried no body sections at all — front matter and
+ * abstract only. Publishers that block full-text XML download still return an
+ * `<article>` with a populated `<front>`, so the parsed article looks like a hit
+ * while carrying nothing to read. Distinct from {@link isSectionFilterMiss},
+ * which needs a non-empty pre-filter body: the two never overlap. Evaluated
+ * against the *pre-filter* article so a `sections` filter can't be mistaken for
+ * an upstream absence. (#86)
+ */
+function isBodylessArticle(before) {
+    return before.sections.length === 0;
+}
 /** Pick the best human-readable identifier for an article whose section filter
  *  missed, for the recovery notice. Treats empty strings as absent — EPMC-only
  *  records carry an empty `pmcId`. */
@@ -80,6 +92,21 @@ function buildSectionFilterMissNotice(affectedIds, sectionFilter) {
     const subject = affectedIds.length === 1 ? `article ${affectedIds[0]}` : `articles ${affectedIds.join(', ')}`;
     return `No body sections matched the requested section filter (${terms}) for ${subject}. The full text was retrieved but every body section was filtered out. Retry without \`sections\`, or filter on broader headings such as Introduction, Methods, Results, or Discussion.`;
 }
+/**
+ * Compose the recovery notice for identifiers whose only retrievable record was
+ * metadata-only — PMC or Europe PMC returned front matter with no body, and no
+ * later tier recovered a full-text copy. Points at the tool that still serves
+ * the abstract so the metadata isn't simply lost.
+ *
+ * States what the chain observed rather than asserting the article has no body:
+ * a later tier may well have located an open-access copy and failed to download
+ * it (`unpaywall:fetch-failed`), so the per-tier outcomes are the honest answer
+ * and the notice defers to them. (#86)
+ */
+function buildBodylessNotice(affectedIds) {
+    const subject = affectedIds.length === 1 ? `article ${affectedIds[0]}` : `articles ${affectedIds.join(', ')}`;
+    return `No body text could be retrieved for ${subject} — the full-text source returned front matter and abstract only, and no later tier recovered a copy. See \`triedTiers\` on the \`unavailable\` entry for what each tier reported, and use \`pubmed_fetch_articles\` for the abstract and metadata.`;
+}
 // ─── Schemas ─────────────────────────────────────────────────────────────────
 const SubsectionSchema = z
     .object({
@@ -173,10 +200,14 @@ const UnpaywallArticleSchema = z
     contentFormat: z
         .enum(['html-markdown', 'pdf-text'])
         .describe('How `content` was extracted. html-markdown: Defuddle extracted Markdown from an HTML landing page; light section structure may survive but is not guaranteed. pdf-text: unpdf extracted plain text from a PDF; no section, reference, or heading structure.'),
+    pmcId: z
+        .string()
+        .optional()
+        .describe('PMC ID this article was requested under, in `PMC<digits>` form — present for `pmcids` input, absent for `pmids` and `dois` input. Ties the article back to the requested identifier, which `unavailable[]` keys on for the ids that found nothing.'),
     pmid: z
         .string()
         .optional()
-        .describe('PubMed ID when input was `pmids`; absent for `dois` input'),
+        .describe('PubMed ID when input was `pmids`; absent for `pmcids` and `dois` input'),
     pubmedUrl: z.string().optional().describe('PubMed URL — present when `pmid` is set'),
     doi: z.string().describe('DOI used to locate the open-access copy'),
     sourceUrl: z.string().describe('URL the content was fetched from'),
@@ -209,25 +240,27 @@ const UnavailableReasonSchema = z
     'not-found',
     'no-pmc-fallback-disabled',
     'no-epmc-fulltext',
+    'no-body',
     'no-doi',
     'no-oa',
     'fetch-failed',
     'parse-failed',
     'service-error',
 ])
-    .describe('Why no full text was returned. not-found: upstream returned no record for this ID. no-pmc-fallback-disabled: every tier was skipped (`triedTiers` is all `not-attempted`) — typically because EPMC (`EUROPEPMC_ENABLED`) and Unpaywall (`UNPAYWALL_EMAIL`) are not configured. no-epmc-fulltext: EPMC indexed the record but publishes no fullTextXML. no-doi: no DOI to query Unpaywall. no-oa: Unpaywall has no OA copy. fetch-failed: download failed. parse-failed: extraction empty. service-error: upstream server failure (threw, timed out, or returned malformed data).');
+    .describe('Why no full text was returned. not-found: upstream returned no record for this ID. no-pmc-fallback-disabled: every tier was skipped (`triedTiers` is all `not-attempted`) — typically because EPMC (`EUROPEPMC_ENABLED`) and Unpaywall (`UNPAYWALL_EMAIL`) are not configured. no-epmc-fulltext: EPMC indexed the record but publishes no fullTextXML. no-body: the record was retrieved but carries front matter and abstract only, with no body sections — use `pubmed_fetch_articles` for the metadata. no-doi: no DOI to query Unpaywall. no-oa: Unpaywall has no OA copy. fetch-failed: download failed. parse-failed: extraction empty. service-error: upstream server failure (threw, timed out, or returned malformed data).');
 const TierOutcomeSchema = z
     .enum([
     'not-attempted',
     'miss',
     'no-fulltext',
+    'no-body',
     'no-doi',
     'no-oa',
     'fetch-failed',
     'parse-failed',
     'service-error',
 ])
-    .describe('Per-tier outcome. not-attempted: tier was skipped. miss: tier returned no record. no-fulltext: EPMC indexed the record but publishes no fullTextXML. no-doi: no DOI to query Unpaywall. no-oa: Unpaywall reports no open-access copy. fetch-failed: OA copy download failed. parse-failed: extraction produced empty content. service-error: tier service threw.');
+    .describe('Per-tier outcome. not-attempted: tier was skipped. miss: tier returned no record. no-fulltext: EPMC indexed the record but publishes no fullTextXML. no-body: the tier returned a record with front matter and abstract but no body sections, so the chain continued. no-doi: no DOI to query Unpaywall. no-oa: Unpaywall reports no open-access copy. fetch-failed: OA copy download failed. parse-failed: extraction produced empty content. service-error: tier service threw.');
 const TriedTierSchema = z
     .object({
     tier: z.enum(['pmc', 'europepmc', 'unpaywall']).describe('Which tier in the resolution chain'),
@@ -306,7 +339,7 @@ export const fetchFulltextTool = tool('pubmed_fetch_fulltext', {
             .min(1)
             .max(10)
             .optional()
-            .describe('PMC IDs to fetch (e.g. ["PMC9575052"]). Provide exactly one of `pmcids`, `pmids`, or `dois`.'),
+            .describe('PMC IDs to fetch (e.g. ["PMC9575052"]). Provide exactly one of `pmcids`, `pmids`, or `dois`. PMC IDs with no retrievable full text fall through to Europe PMC, then to Unpaywall on the DOI the chain resolves for them.'),
         pmids: z
             .array(pmidStringSchema)
             .min(1)
@@ -346,14 +379,15 @@ export const fetchFulltextTool = tool('pubmed_fetch_fulltext', {
             .optional()
             .describe('Per-identifier explanations for any requested PMIDs, PMCIDs, or DOIs with no returnable full text. `idType` discriminates which branch the id came from.'),
     }),
-    // Recovery guidance when a `sections` filter removes every body section from
-    // an article that has one — agent-facing context surfaced via ctx.enrich.notice()
-    // to structuredContent and content[]; absent when no filter ran or sections matched. (#80)
+    // Recovery guidance for two empty-body cases — a `sections` filter that removed
+    // every body section (#80), and a record the chain could only retrieve as front
+    // matter (#86). Agent-facing context surfaced via ctx.enrich.notice() to
+    // structuredContent and content[]; absent when neither applies.
     enrichment: {
         notice: z
             .string()
             .optional()
-            .describe('Optional guidance when a `sections` filter removed every body section — names the requested section terms and the affected article id(s), and suggests retrying without `sections` or using broader headings. Absent when no section filter was applied or sections matched.'),
+            .describe('Optional guidance for empty bodies. A `sections`-filter miss names the requested terms and affected article id(s) and suggests retrying without `sections` or using broader headings. A metadata-only record names the id(s) the chain could retrieve as front matter only and points at `pubmed_fetch_articles` for the abstract. Absent when neither case applies.'),
     },
     async handler(input, ctx) {
         ctx.log.info('Executing pubmed_fetch_fulltext', {
@@ -380,6 +414,10 @@ export const fetchFulltextTool = tool('pubmed_fetch_fulltext', {
         // section — collected across the PMC and EPMC stages to drive one recovery
         // notice via ctx.enrich.notice (#80).
         const sectionFilterMisses = [];
+        // Input ids whose PMC or EPMC record carried no body sections at all. Those
+        // records are not full-text hits, so the chain continues past them; ids still
+        // unrecovered at the end drive the metadata-only recovery notice (#86).
+        const bodylessInputIds = new Set();
         const idType = input.pmids ? 'pmid' : input.pmcids ? 'pmcid' : 'doi';
         // ── Branch routing → produce buckets the staged chain consumes ──────────
         let pmcIds = [];
@@ -511,19 +549,26 @@ export const fetchFulltextTool = tool('pubmed_fetch_fulltext', {
                 if (!articleSet) {
                     throw new Error('PMC EFetch response missing pmc-articleset wrapper');
                 }
-                const parsed = findAll(articleSet, 'article').map((node) => {
+                // A parsed article with no body sections is front matter only — PMC
+                // returns one whenever the publisher blocks full-text XML download. It
+                // is not a hit: it never enters `articles[]`, and its id is routed to
+                // the remaining tiers like any other PMC miss. (#86)
+                const bodylessPmcIds = new Set();
+                const parsed = [];
+                for (const node of findAll(articleSet, 'article')) {
                     const before = parsePmcArticle(node);
+                    if (isBodylessArticle(before)) {
+                        if (before.pmcId)
+                            bodylessPmcIds.add(before.pmcId);
+                        continue;
+                    }
                     const after = applyPmcFilters(before, input);
                     if (isSectionFilterMiss(before, after, input.sections)) {
                         sectionFilterMisses.push(articleSectionMissId(after));
                     }
-                    return after;
-                });
-                pmcArticles = parsed.map((a) => ({
-                    source: 'pmc',
-                    viaSource: 'pmc',
-                    ...a,
-                }));
+                    parsed.push({ source: 'pmc', viaSource: 'pmc', ...after });
+                }
+                pmcArticles = parsed;
                 const returnedPmcIds = new Set(pmcArticles.map((a) => a.pmcId).filter((id) => !!id));
                 for (const prefixed of returnedPmcIds) {
                     recoveredIds.add(pmcidToInputId.get(prefixed) ?? prefixed);
@@ -533,7 +578,17 @@ export const fetchFulltextTool = tool('pubmed_fetch_fulltext', {
                     .filter((id) => !returnedPmcIds.has(id));
                 for (const prefixed of missing) {
                     const inputId = pmcidToInputId.get(prefixed) ?? prefixed;
-                    chainByInput.get(inputId)?.push({ tier: 'pmc', outcome: 'miss' });
+                    if (bodylessPmcIds.has(prefixed)) {
+                        bodylessInputIds.add(inputId);
+                        chainByInput.get(inputId)?.push({
+                            tier: 'pmc',
+                            outcome: 'no-body',
+                            detail: 'PMC returned front matter and abstract only, with no body sections',
+                        });
+                    }
+                    else {
+                        chainByInput.get(inputId)?.push({ tier: 'pmc', outcome: 'miss' });
+                    }
                 }
                 routePmcMissesToFallback(missing);
             }
@@ -590,28 +645,22 @@ export const fetchFulltextTool = tool('pubmed_fetch_fulltext', {
                 chainByInput.get(c.doi)?.push(epmcDisabledEntry);
         }
         else {
-            for (const [pmid, outcome] of epmcOutcomes.pmidOutcomes) {
-                if (outcome.kind === 'hit') {
-                    recoveredIds.add(pmid);
-                    continue;
-                }
-                chainByInput.get(pmid)?.push(epmcTierFromOutcome(outcome));
-            }
-            for (const [prefixed, outcome] of epmcOutcomes.pmcidOutcomes) {
-                const inputId = pmcidToInputId.get(prefixed) ?? prefixed;
+            const foldEpmcOutcome = (inputId, outcome) => {
                 if (outcome.kind === 'hit') {
                     recoveredIds.add(inputId);
-                    continue;
+                    return;
                 }
+                if (outcome.kind === 'no-body')
+                    bodylessInputIds.add(inputId);
                 chainByInput.get(inputId)?.push(epmcTierFromOutcome(outcome));
+            };
+            for (const [pmid, outcome] of epmcOutcomes.pmidOutcomes)
+                foldEpmcOutcome(pmid, outcome);
+            for (const [prefixed, outcome] of epmcOutcomes.pmcidOutcomes) {
+                foldEpmcOutcome(pmcidToInputId.get(prefixed) ?? prefixed, outcome);
             }
-            for (const [doi, outcome] of epmcOutcomes.doiOutcomes) {
-                if (outcome.kind === 'hit') {
-                    recoveredIds.add(doi);
-                    continue;
-                }
-                chainByInput.get(doi)?.push(epmcTierFromOutcome(outcome));
-            }
+            for (const [doi, outcome] of epmcOutcomes.doiOutcomes)
+                foldEpmcOutcome(doi, outcome);
         }
         pmidFallbackCandidates = epmcOutcomes.remainingPmid;
         pmcidFallbackCandidates = epmcOutcomes.remainingPmcid;
@@ -620,15 +669,76 @@ export const fetchFulltextTool = tool('pubmed_fetch_fulltext', {
         // ── Stage 3: Unpaywall fallback ─────────────────────────────────────────
         const unpaywall = getUnpaywallService();
         const fallbackArticles = [];
-        // PMC misses on `pmcids` input don't get an Unpaywall attempt — the current
-        // implementation doesn't resolve PMCID → DOI for that branch.
-        for (const c of pmcidFallbackCandidates) {
-            const prefixed = withPmcPrefix(c.pmcid);
-            chainByInput.get(pmcidToInputId.get(prefixed) ?? prefixed)?.push({
-                tier: 'unpaywall',
-                outcome: 'not-attempted',
-                detail: 'pmcids input does not resolve a DOI for Unpaywall',
-            });
+        // `pmcids` input reaches Unpaywall on the DOI the chain already holds: the
+        // EPMC stage searches by PMCID and its hit carries one, captured on non-hit
+        // outcomes too. PMCIDs EPMC never resolved fall back to the PMC ID
+        // Converter, which returns DOIs for PMC-indexed records. (#88)
+        if (pmcidFallbackCandidates.length > 0) {
+            if (!unpaywall) {
+                for (const c of pmcidFallbackCandidates) {
+                    const prefixed = withPmcPrefix(c.pmcid);
+                    chainByInput.get(pmcidToInputId.get(prefixed) ?? prefixed)?.push({
+                        tier: 'unpaywall',
+                        outcome: 'not-attempted',
+                        detail: 'UNPAYWALL_EMAIL is not set',
+                    });
+                }
+            }
+            else {
+                const needDoi = pmcidFallbackCandidates
+                    .filter((c) => !c.doi)
+                    .map((c) => withPmcPrefix(c.pmcid));
+                if (needDoi.length > 0) {
+                    try {
+                        const records = await getNcbiService().idConvert(needDoi, 'pmcid', ctx.signal ? { signal: ctx.signal } : undefined);
+                        const doiByPmcid = new Map();
+                        for (const r of records) {
+                            if (r.pmcid && r.doi) {
+                                doiByPmcid.set(withPmcPrefix(normalizePmcId(String(r.pmcid))), String(r.doi));
+                            }
+                        }
+                        pmcidFallbackCandidates = pmcidFallbackCandidates.map((c) => {
+                            if (c.doi)
+                                return c;
+                            const doi = doiByPmcid.get(withPmcPrefix(c.pmcid));
+                            return doi ? { ...c, doi } : c;
+                        });
+                    }
+                    catch (error) {
+                        ctx.log.warning('Failed to resolve PMCID → DOI for the Unpaywall fallback', {
+                            error: error instanceof Error ? error.message : String(error),
+                            pmcidCount: needDoi.length,
+                        });
+                    }
+                }
+                const outcomes = await Promise.all(pmcidFallbackCandidates.map(async (candidate) => {
+                    // The prefixed PMCID is the id `unavailable[]` keys on, so stamping
+                    // it on the article makes a partially-recovered batch report its
+                    // successes and its failures under the same identifier. (#92)
+                    const pmcId = withPmcPrefix(candidate.pmcid);
+                    return {
+                        pmcId,
+                        result: candidate.doi
+                            ? await resolveUnpaywall({ pmcId, doi: candidate.doi }, unpaywall, ctx)
+                            : { unavailable: { reason: 'no-doi' } },
+                    };
+                }));
+                for (const { pmcId, result } of outcomes) {
+                    const inputId = pmcidToInputId.get(pmcId) ?? pmcId;
+                    if ('article' in result) {
+                        fallbackArticles.push(result.article);
+                        recoveredIds.add(inputId);
+                    }
+                    else {
+                        const u = result.unavailable;
+                        chainByInput.get(inputId)?.push({
+                            tier: 'unpaywall',
+                            outcome: unpaywallReasonToTierOutcome(u.reason),
+                            ...(u.detail && { detail: u.detail }),
+                        });
+                    }
+                }
+            }
         }
         if (pmidFallbackCandidates.length > 0) {
             // The PMC ID Converter only returns DOIs for articles it has in PMC, so
@@ -738,9 +848,17 @@ export const fetchFulltextTool = tool('pubmed_fetch_fulltext', {
             unpaywallHits: fallbackArticles.length,
             unavailable: unavailable.length,
         });
+        // Only the last ctx.enrich.notice survives, so the applicable fragments are
+        // collected and emitted once.
+        const notices = [];
         if (input.sections?.length && sectionFilterMisses.length > 0) {
-            ctx.enrich.notice(buildSectionFilterMissNotice(sectionFilterMisses, input.sections));
+            notices.push(buildSectionFilterMissNotice(sectionFilterMisses, input.sections));
         }
+        const unrecoveredBodyless = [...bodylessInputIds].filter((id) => !recoveredIds.has(id));
+        if (unrecoveredBodyless.length > 0)
+            notices.push(buildBodylessNotice(unrecoveredBodyless));
+        if (notices.length > 0)
+            ctx.enrich.notice(notices.join(' '));
         return {
             articles,
             totalReturned: articles.length,
@@ -795,27 +913,42 @@ async function runEpmcStage(epmc, args) {
         }
         if (search.kind === 'miss')
             return { c, outcome: { kind: 'miss' } };
+        const doi = search.hit.doi ? { doi: search.hit.doi } : {};
         const fetched = await fetchEpmcArticle(epmc, search.hit, args, contextPmid);
         if (fetched.kind === 'error') {
-            return { c, outcome: { kind: 'service-error', detail: fetched.detail } };
+            return { c, ...doi, outcome: { kind: 'service-error', detail: fetched.detail } };
         }
         if (fetched.kind === 'no-fulltext') {
             return {
                 c,
+                ...doi,
                 outcome: { kind: 'no-fulltext', ...(fetched.detail && { detail: fetched.detail }) },
             };
         }
+        if (fetched.kind === 'no-body') {
+            return { c, ...doi, outcome: { kind: 'no-body', detail: fetched.detail } };
+        }
         return {
             c,
+            ...doi,
             outcome: { kind: 'hit' },
             article: fetched.article,
             sectionFilterMiss: fetched.sectionFilterMiss,
         };
     };
-    const fetchForPmid = (c) => runOne(c, `EXT_ID:"${c.pmid}" AND SRC:MED`, c.pmid);
+    /**
+     * Query shapes are load-bearing and not interchangeable with their quoted
+     * variants. Europe PMC matches zero records for `EXT_ID:"<pmid>" AND SRC:MED`
+     * and `PMCID:"PMC<digits>"` — the quotes only survive as long as no `AND SRC:`
+     * clause follows. `SRC:PMC` is likewise wrong for a PMCID lookup: EPMC's
+     * canonical record for a PMC-indexed article has `source: MED` and carries the
+     * PMCID as a field, so the filter excludes the very record being sought. DOIs
+     * keep their quotes — they carry slashes and dots that need them. (#85)
+     */
+    const fetchForPmid = (c) => runOne(c, `EXT_ID:${c.pmid} AND SRC:MED`, c.pmid);
     const fetchForPmcid = (c) => {
         const normalized = withPmcPrefix(c.pmcid);
-        return runOne({ c, normalized }, `PMCID:"${normalized}" AND SRC:PMC`, undefined);
+        return runOne({ c, normalized }, `PMCID:${normalized}`, undefined);
     };
     const fetchForDoi = (c) => runOne(c, `DOI:"${c.doi}"`, undefined);
     const [pmidResults, pmcidResults, doiResults] = await Promise.all([
@@ -841,7 +974,7 @@ async function runEpmcStage(epmc, args) {
         else
             remainingPmid.push(c);
     }
-    for (const { c: pair, outcome, article, sectionFilterMiss } of pmcidResults) {
+    for (const { c: pair, outcome, article, sectionFilterMiss, doi } of pmcidResults) {
         pmcidOutcomes.set(pair.normalized, outcome);
         if (article) {
             articles.push(article);
@@ -849,7 +982,7 @@ async function runEpmcStage(epmc, args) {
                 sectionFilterMisses.push(articleSectionMissId(article));
         }
         else
-            remainingPmcid.push(pair.c);
+            remainingPmcid.push(doi && !pair.c.doi ? { ...pair.c, doi } : pair.c);
     }
     for (const { c, outcome, article, sectionFilterMiss } of doiResults) {
         doiOutcomes.set(c.doi, outcome);
@@ -923,6 +1056,12 @@ async function fetchEpmcArticle(epmc, hit, args, contextPmid) {
             return { kind: 'no-fulltext', detail: 'EPMC fullTextXML payload had no <article> element' };
         }
         const beforeFilter = parsePmcArticle(articleNode);
+        if (isBodylessArticle(beforeFilter)) {
+            return {
+                kind: 'no-body',
+                detail: 'EPMC fullTextXML carried front matter and abstract only, with no body sections',
+            };
+        }
         const parsed = applyPmcFilters(beforeFilter, args.input);
         const sectionFilterMiss = isSectionFilterMiss(beforeFilter, parsed, args.input.sections);
         // `parsePmcArticle` always returns string fields (sometimes empty). Strip
@@ -987,12 +1126,13 @@ async function fetchPubmedDois(pmids, signal) {
     return out;
 }
 /**
- * Resolve a DOI to an open-access article via Unpaywall. `pmid`, when set,
- * is stamped onto the resulting article so the pmid-input branch carries its
- * cross-reference through.
+ * Resolve a DOI to an open-access article via Unpaywall. `pmcId` and `pmid`,
+ * when set, are stamped onto the resulting article so the branch that requested
+ * it carries its identifier through — Unpaywall itself only knows the DOI.
  */
 async function resolveUnpaywall(args, service, ctx) {
-    const { pmid, doi } = args;
+    const { pmcId, pmid, doi } = args;
+    const requestedIds = { ...(pmcId && { pmcId }), ...(pmid && { pmid }) };
     let resolution;
     try {
         resolution = await service.resolve(doi, ctx.signal);
@@ -1031,7 +1171,7 @@ async function resolveUnpaywall(args, service, ctx) {
             }
             return {
                 article: buildUnpaywallArticle({
-                    ...(pmid && { pmid }),
+                    ...requestedIds,
                     doi,
                     sourceUrl: content.fetchedUrl,
                     location: resolution.location,
@@ -1051,7 +1191,7 @@ async function resolveUnpaywall(args, service, ctx) {
         }
         return {
             article: buildUnpaywallArticle({
-                ...(pmid && { pmid }),
+                ...requestedIds,
                 doi,
                 sourceUrl: content.fetchedUrl,
                 location: resolution.location,
@@ -1073,6 +1213,7 @@ function buildUnpaywallArticle(args) {
         source: 'unpaywall',
         viaSource: 'unpaywall',
         contentFormat: args.contentFormat,
+        ...(args.pmcId && { pmcId: args.pmcId }),
         ...(args.pmid && {
             pmid: args.pmid,
             pubmedUrl: `https://pubmed.ncbi.nlm.nih.gov/${args.pmid}/`,
@@ -1103,6 +1244,8 @@ function epmcTierFromOutcome(outcome) {
                 outcome: 'no-fulltext',
                 ...(outcome.detail && { detail: outcome.detail }),
             };
+        case 'no-body':
+            return { tier: 'europepmc', outcome: 'no-body', detail: outcome.detail };
         case 'service-error':
             return { tier: 'europepmc', outcome: 'service-error', detail: outcome.detail };
     }
@@ -1116,6 +1259,7 @@ function epmcTierFromOutcome(outcome) {
  */
 function unpaywallReasonToTierOutcome(reason) {
     switch (reason) {
+        case 'no-body':
         case 'no-doi':
         case 'no-oa':
         case 'fetch-failed':
@@ -1152,6 +1296,9 @@ function reasonFromChain(chain) {
             return 'not-found';
         case 'europepmc:no-fulltext':
             return 'no-epmc-fulltext';
+        case 'pmc:no-body':
+        case 'europepmc:no-body':
+            return 'no-body';
         case 'unpaywall:no-doi':
             return 'no-doi';
         case 'unpaywall:no-oa':
@@ -1245,12 +1392,15 @@ function formatPmcArticle(a, lines) {
     }
 }
 function formatUnpaywallArticle(a, lines) {
-    const heading = a.title ?? (a.pmid ? `PMID ${a.pmid}` : `DOI ${a.doi}`);
+    const requestedId = a.pmcId ? `PMCID ${a.pmcId}` : a.pmid ? `PMID ${a.pmid}` : `DOI ${a.doi}`;
+    const heading = a.title ?? requestedId;
     const formatLabel = a.contentFormat === 'html-markdown'
         ? 'Unpaywall (HTML → Markdown, best-effort)'
         : 'Unpaywall (PDF → plain text)';
     lines.push(`### ${heading}`);
     lines.push(`**Source:** ${formatLabel}`);
+    if (a.pmcId)
+        lines.push(`**PMCID:** ${a.pmcId}`);
     if (a.pmid)
         lines.push(`**PMID:** ${a.pmid}`);
     lines.push(`**DOI:** ${a.doi}`);